loopx 0.4.8__py3-none-any.whl

loopx/control_plane/agents/multi_agent/runtime_scripts.py

@@ -0,0 +1,426 @@
+from __future__ import annotations
+
+
+SCOPED_LOOPX_WRAPPER_PY = r"""
+import os
+from pathlib import Path
+
+project = Path(os.environ["LOOPX_PROJECT"])
+real = os.environ["LOOPX_REAL_CLI"]
+registry = os.environ["LOOPX_REGISTRY"]
+runtime = os.environ["LOOPX_RUNTIME_ROOT"]
+bin_dir = project / ".local" / "bin"
+bin_dir.mkdir(parents=True, exist_ok=True)
+
+json_target = bin_dir / "loopx-json"
+json_target.write_text(
+    "#!/usr/bin/env python3\n"
+    "import os, stat, sys\n"
+    f"real = {real!r}\n"
+    f"registry = {registry!r}\n"
+    f"runtime = {runtime!r}\n"
+    "explicit = os.environ.get('LOOPX_MACHINE_JSON') == '1' or os.environ.get('LOOPX_ALLOW_TTY_JSON') == '1' or os.environ.get('LOOPX_ALLOW_VISIBLE_JSON') == '1'\n"
+    "stdout_mode = os.fstat(sys.stdout.fileno()).st_mode\n"
+    "stdout_is_file = stat.S_ISREG(stdout_mode)\n"
+    "if not explicit and not stdout_is_file:\n"
+    "    print('\\n[LoopX machine JSON hidden]\\nraw JSON is not printed in visible panes.\\n')\n"
+    "    print('Use $LOOPX_PANE_LOOPX for human-readable output, or redirect machine JSON:')\n"
+    "    print('  mkdir -p \"$LOOPX_PANE_ARTIFACT_DIR\"')\n"
+    "    print('  $LOOPX_PANE_LOOPX_JSON <command> > \"$LOOPX_PANE_ARTIFACT_DIR/<name>.public.json\"')\n"
+    "    print('$LOOPX_PANE_LOOPX_JSON is a command path, not an output file.')\n"
+    "    print('It injects --format json unless you pass an explicit --format.')\n"
+    "    print('Internal launcher pipes must set LOOPX_MACHINE_JSON=1 explicitly.')\n"
+    "    raise SystemExit(2)\n"
+    "args = sys.argv[1:]\n"
+    "has_format = any(arg == '--format' or arg.startswith('--format=') for arg in args)\n"
+    "if not has_format:\n"
+    "    args = ['--format', 'json'] + args\n"
+    "os.execv(real, [real, '--registry', registry, '--runtime-root', runtime] + args)\n",
+    encoding="utf-8",
+)
+json_target.chmod(0o700)
+
+human_target = bin_dir / "loopx"
+human_target.write_text(
+    "#!/usr/bin/env python3\n"
+    "import os, sys\n"
+    f"real = {real!r}\n"
+    f"registry = {registry!r}\n"
+    f"runtime = {runtime!r}\n"
+    "args = sys.argv[1:]\n"
+    "force = os.environ.get('LOOPX_VISIBLE_FORCE_MARKDOWN', '1') != '0'\n"
+    "machine_json = os.environ.get('LOOPX_MACHINE_JSON') == '1'\n"
+    "changed = False\n"
+    "if force and not machine_json:\n"
+    "    rewritten = []\n"
+    "    index = 0\n"
+    "    while index < len(args):\n"
+    "        arg = args[index]\n"
+    "        if arg == '--format' and index + 1 < len(args):\n"
+    "            rewritten.append(arg)\n"
+    "            value = args[index + 1]\n"
+    "            if value == 'json':\n"
+    "                value = 'markdown'\n"
+    "                changed = True\n"
+    "            rewritten.append(value)\n"
+    "            index += 2\n"
+    "            continue\n"
+    "        if arg == '--format=json':\n"
+    "            arg = '--format=markdown'\n"
+    "            changed = True\n"
+    "        rewritten.append(arg)\n"
+    "        index += 1\n"
+    "    args = rewritten\n"
+    "if changed:\n"
+    "    print('\\n[LoopX human view]\\nformat=markdown; machine_json_command=$LOOPX_PANE_LOOPX_JSON artifact_dir=$LOOPX_PANE_ARTIFACT_DIR\\n', flush=True)\n"
+    "os.execv(real, [real, '--registry', registry, '--runtime-root', runtime] + args)\n",
+    encoding="utf-8",
+)
+human_target.chmod(0o700)
+
+prompt_target = bin_dir / "loopx-build-codex-bootstrap-prompt"
+prompt_target.write_text(
+    "#!/usr/bin/env python3\n"
+    "import json, os, sys\n"
+    "from pathlib import Path\n"
+    "def load_json_path(value):\n"
+    "    if not value:\n"
+    "        return {}\n"
+    "    try:\n"
+    "        return json.loads(Path(value).read_text(encoding='utf-8'))\n"
+    "    except Exception:\n"
+    "        return {}\n"
+    "def compact(value, *, default=''):\n"
+    "    text = ' '.join(str(value or '').split())\n"
+    "    return text[:240] if text else default\n"
+    "def compact_list(value):\n"
+    "    if isinstance(value, list):\n"
+    "        return ', '.join(compact(item) for item in value if compact(item))\n"
+    "    return compact(value)\n"
+    "def latest_selected_round(summary):\n"
+    "    rounds = summary.get('rounds') if isinstance(summary, dict) else []\n"
+    "    if not isinstance(rounds, list):\n"
+    "        return {}\n"
+    "    for item in reversed(rounds):\n"
+    "        if isinstance(item, dict) and (item.get('selected_todo_id') or item.get('selected_action')):\n"
+    "            return item\n"
+    "    return {}\n"
+    "artifact = Path(sys.argv[1]) if len(sys.argv) > 1 else Path(os.environ.get('LOOPX_CODEX_TUI_PROMPT_ARTIFACT', ''))\n"
+    "visible_artifact = Path(sys.argv[2]) if len(sys.argv) > 2 and sys.argv[2] else None\n"
+    "if not str(artifact):\n"
+    "    raise SystemExit(2)\n"
+    "base = artifact.read_text(encoding='utf-8') if artifact.exists() else ''\n"
+    "profile = load_json_path(os.environ.get('LOOPX_ROLE_PROFILE_ARTIFACT'))\n"
+    "summary = load_json_path(os.environ.get('LOOPX_PANE_TICK_SUMMARY'))\n"
+    "round_item = latest_selected_round(summary)\n"
+    "language = compact(profile.get('output_language') or os.environ.get('LOOPX_AUTO_RESEARCH_OUTPUT_LANGUAGE'))\n"
+    "open_question = compact(profile.get('open_question'))\n"
+    "preset_context = profile.get('preset_context') if isinstance(profile.get('preset_context'), dict) else {}\n"
+    "benchmark_contract = compact(preset_context.get('benchmark_contract_file'))\n"
+    "editable_scope = compact_list(preset_context.get('editable_scope'))\n"
+    "protected_scope = compact_list(preset_context.get('protected_scope'))\n"
+    "dev_eval_command = compact(preset_context.get('dev_eval_command'))\n"
+    "holdout_eval_command = compact(preset_context.get('holdout_eval_command'))\n"
+    "language_note = ''\n"
+    "if language == 'zh':\n"
+    "    language_note = 'use Chinese for human-readable progress; keep machine keys unchanged'\n"
+    "elif language:\n"
+    "    language_note = 'use this language for human-readable progress; keep machine keys unchanged'\n"
+    "lines = ['', '## LoopX Agent Bootstrap Context']\n"
+    "lines.append('- audience: role-local Codex agent; keep user-facing summaries compact.')\n"
+    "lines.append(f\"- agent_id: {compact(profile.get('agent_id') or os.environ.get('LOOPX_AGENT_ID'), default='unknown')}\")\n"
+    "lines.append(f\"- role_id: {compact(profile.get('role_id') or os.environ.get('LOOPX_ROLE_ID'), default='unknown')}\")\n"
+    "if open_question:\n"
+    "    lines.append(f'- open_question: {open_question}')\n"
+    "if preset_context:\n"
+    "    lines.append(f\"- preset_context: preset={compact(preset_context.get('preset_id'), default='none')} metric={compact(preset_context.get('metric_name'), default='none')} baseline={compact(preset_context.get('baseline_metric'), default='none')}\")\n"
+    "    claim_boundary = compact(preset_context.get('claim_boundary'))\n"
+    "    if claim_boundary:\n"
+    "        lines.append(f'- claim_boundary: {claim_boundary}')\n"
+    "    if benchmark_contract or editable_scope or protected_scope or dev_eval_command or holdout_eval_command:\n"
+    "        lines.extend(['', '### Benchmark Workspace'])\n"
+    "        if benchmark_contract:\n"
+    "            lines.append(f'- benchmark_contract: {benchmark_contract}')\n"
+    "        if editable_scope:\n"
+    "            lines.append(f'- editable_scope: {editable_scope}')\n"
+    "        if protected_scope:\n"
+    "            lines.append(f'- protected_scope: {protected_scope}')\n"
+    "        if dev_eval_command:\n"
+    "            lines.append(f'- dev_eval_command: `{dev_eval_command}`')\n"
+    "        if holdout_eval_command:\n"
+    "            lines.append(f'- holdout_eval_command: `{holdout_eval_command}`')\n"
+    "responsibility = compact(profile.get('responsibility') or profile.get('agent_scope'))\n"
+    "if responsibility:\n"
+    "    lines.append(f'- responsibility: {responsibility}')\n"
+    "if language_note:\n"
+    "    lines.append(f'- human_output_language: {language}; {language_note}.')\n"
+    "visible_first_steps = profile.get('visible_first_steps') if isinstance(profile.get('visible_first_steps'), list) else []\n"
+    "visible_first_steps = [compact(item) for item in visible_first_steps if compact(item)]\n"
+    "if visible_first_steps:\n"
+    "    lines.extend(['', '### Role First Move'])\n"
+    "    for item in visible_first_steps[:6]:\n"
+    "        lines.append(f'- {item}')\n"
+    "continuation_policy = profile.get('continuation_policy') if isinstance(profile.get('continuation_policy'), dict) else {}\n"
+    "continuation_line = ''\n"
+    "if continuation_policy:\n"
+    "    required_holdouts = compact(continuation_policy.get('required_holdout_improvement_count'), default='')\n"
+    "    successor_source = compact(continuation_policy.get('successor_source'), default='role_profile.successor_todos')\n"
+    "    if required_holdouts:\n"
+    "        continuation_line = f'target_holdout_improvements={required_holdouts}; if unmet, use {successor_source} before no-follow-up'\n"
+    "    else:\n"
+    "        continuation_line = f'if acceptance target is unmet, use {successor_source} before no-follow-up'\n"
+    "if continuation_line:\n"
+    "    lines.extend(['', '### Continuation Target', f'- {continuation_line}'])\n"
+    "lines.extend(['', '### Current Frontier'])\n"
+    "if round_item:\n"
+    "    lines.append(f\"- selected_todo_id: {compact(round_item.get('selected_todo_id'), default='unknown')}\")\n"
+    "    lines.append(f\"- selected_action: {compact(round_item.get('selected_action'), default='unknown')}\")\n"
+    "    lines.append(f\"- worker_status: {compact(round_item.get('worker_status'), default='unknown')}\")\n"
+    "else:\n"
+    "    lines.append('- selected_frontier: not read yet; this Codex TUI owns the first pane-local tick.')\n"
+    "lines.extend(['', '### Safety Contract'])\n"
+    "lines.append('- protected_scope_rule: do not edit protected evaluator/data, credentials, private material, or raw logs.')\n"
+    "lines.append('- claim_allowed_rule: false until role-authored public-safe evidence validates; do not promote from dev-only evidence.')\n"
+    "lines.append('- successor_rule: create only role-declared successor todos through normal LoopX todo commands.')\n"
+    "lines.extend(['', '### Visible Research Rule'])\n"
+    "lines.append('- tick_rule: pane-local tick reads quota/frontier/status only; it must not manufacture research conclusions.')\n"
+    "lines.append('- evidence_rule: write only lane-authored public-safe evidence or successor todos after doing visible role work.')\n"
+    "full_prompt = base.rstrip() + '\\n\\n' + '\\n'.join(lines).strip() + '\\n'\n"
+    "artifact.write_text(full_prompt, encoding='utf-8')\n"
+    "selected_todo = compact(round_item.get('selected_todo_id'), default='none') if round_item else 'none'\n"
+    "selected_action = compact(round_item.get('selected_action'), default='none') if round_item else 'none'\n"
+    "frontier_text_zh = f'{selected_todo} / {selected_action}' if round_item else 'tick 后读取；若仍为空，用 todo list/status 查本角色 open todo'\n"
+    "frontier_text_en = f'{selected_todo} / {selected_action}' if round_item else 'read after tick; if still empty, use todo list/status to find this role open todo'\n"
+    "benchmark_lines_zh = []\n"
+    "benchmark_lines_en = []\n"
+    "if benchmark_contract:\n"
+    "    benchmark_lines_zh.append(f'- benchmark 合同: {benchmark_contract}')\n"
+    "    benchmark_lines_en.append(f'- benchmark contract: {benchmark_contract}')\n"
+    "if editable_scope:\n"
+    "    benchmark_lines_zh.append(f'- 可改文件: {editable_scope}')\n"
+    "    benchmark_lines_en.append(f'- editable files: {editable_scope}')\n"
+    "if protected_scope:\n"
+    "    benchmark_lines_zh.append(f'- 保护文件: {protected_scope}')\n"
+    "    benchmark_lines_en.append(f'- protected files: {protected_scope}')\n"
+    "if dev_eval_command:\n"
+    "    benchmark_lines_zh.append(f'- dev 验证: `{dev_eval_command}`')\n"
+    "    benchmark_lines_en.append(f'- dev eval: `{dev_eval_command}`')\n"
+    "if holdout_eval_command:\n"
+    "    benchmark_lines_zh.append(f'- held-out 验证: `{holdout_eval_command}`')\n"
+    "    benchmark_lines_en.append(f'- held-out eval: `{holdout_eval_command}`')\n"
+    "continuation_lines_zh = []\n"
+    "continuation_lines_en = []\n"
+    "if continuation_line:\n"
+    "    continuation_lines_zh.append(f'- 续轮规则: {continuation_line}')\n"
+    "    continuation_lines_en.append(f'- continuation rule: {continuation_line}')\n"
+    "if visible_artifact:\n"
+    "    first_step_lines_zh = [f'- 首轮动作: {item}' for item in visible_first_steps[:6]]\n"
+    "    first_step_lines_en = [f'- first move: {item}' for item in visible_first_steps[:6]]\n"
+    "    if language == 'zh':\n"
+    "        visible_lines = [\n"
+    "            '请用中文继续这个 LoopX auto-research pane。',\n"
+    "            f'- 角色: {compact(profile.get(\"role_id\") or os.environ.get(\"LOOPX_ROLE_ID\"), default=\"unknown\")}',\n"
+    "            f'- 研究问题: {open_question or \"未提供\"}',\n"
+    "            f'- Preset: {compact(preset_context.get(\"preset_id\"), default=\"none\")} / metric={compact(preset_context.get(\"metric_name\"), default=\"none\")} / baseline={compact(preset_context.get(\"baseline_metric\"), default=\"none\")}',\n"
+    "            f'- 当前 frontier: {frontier_text_zh}',\n"
+    "            *benchmark_lines_zh,\n"
+    "            *first_step_lines_zh,\n"
+    "            *continuation_lines_zh,\n"
+    "            '- 先运行 `$LOOPX_PANE_A2A_TICK` 一次读取本 pane 的 quota/frontier；tick 是 guard/status，不会替你生成研究结论。',\n"
+    "            '- 若 tick 没有选中 todo，不要关闭 todo 或自行记录 gap；先用 `$LOOPX_PANE_LOOPX todo list --goal-id \"$LOOPX_GOAL_ID\"` 确认本角色是否在等待 resume gate。只有发现未 gate 的本角色 open todo 时，才继续执行上面的首轮动作；不要一上来 diagnose。',\n"
+    "            '- tick 只读取 LoopX state；不要把 tick 产物当作研究证明。',\n"
+    "            '- 如果 tick 显示 no_worker_command_configured 或 manual_research_required，请按本角色亲自研究并写 public-safe evidence/todo，不要把 tick 完成当作研究完成。',\n"
+    "            '- 如果你完成了当前 selected todo 的真实动作，请用 LoopX todo/evidence 命令写回并完成该 todo；下游 resume gate 依赖 todo_done 状态进入下一轮。',\n"
+    "            '- 完成真实研究动作后用 3-5 行中文说明：产出了什么证据、下一步能否自动做、是否需要用户 gate。',\n"
+    "            '- 需要细节时再读取 $LOOPX_CODEX_FULL_BOOTSTRAP_ARTIFACT 和 $LOOPX_PANE_TICK_SUMMARY；不要把完整 bootstrap 合约当作用户首屏复述。',\n"
+    "        ]\n"
+    "    else:\n"
+    "        visible_lines = [\n"
+    "            'Continue this LoopX auto-research pane.',\n"
+    "            f'- role: {compact(profile.get(\"role_id\") or os.environ.get(\"LOOPX_ROLE_ID\"), default=\"unknown\")}',\n"
+    "            f'- open question: {open_question or \"not provided\"}',\n"
+    "            f'- preset: {compact(preset_context.get(\"preset_id\"), default=\"none\")} / metric={compact(preset_context.get(\"metric_name\"), default=\"none\")} / baseline={compact(preset_context.get(\"baseline_metric\"), default=\"none\")}',\n"
+    "            f'- current frontier: {frontier_text_en}',\n"
+    "            *benchmark_lines_en,\n"
+    "            *first_step_lines_en,\n"
+    "            *continuation_lines_en,\n"
+    "            '- Run `$LOOPX_PANE_A2A_TICK` once to read this pane quota/frontier; the tick is guard/status and does not generate research conclusions for you.',\n"
+    "            '- If the tick has no selected todo, do not close a todo or record a gap by yourself; first use `$LOOPX_PANE_LOOPX todo list --goal-id \"$LOOPX_GOAL_ID\"` to check whether this role is waiting on a resume gate. Continue with the first move above only when you find an ungated open todo for this role, and do not start with diagnose.',\n"
+    "            '- The tick only reads LoopX state; do not treat tick output as research proof.',\n"
+    "            '- If the tick reports no_worker_command_configured or manual_research_required, perform this role research yourself and write public-safe evidence/todos; do not treat tick completion as research completion.',\n"
+    "            '- If you complete the real work for the current selected todo, write back through LoopX todo/evidence commands and complete that todo; downstream resume gates rely on todo_done to enter the next round.',\n"
+    "            '- After real research work, reply with a compact 3-5 line progress/status summary: evidence produced, what can run next, and whether a user gate is needed.',\n"
+    "            '- Read $LOOPX_CODEX_FULL_BOOTSTRAP_ARTIFACT and $LOOPX_PANE_TICK_SUMMARY only when details are needed; do not replay the full bootstrap contract as the first screen.',\n"
+    "        ]\n"
+    "    visible_artifact.write_text('\\n'.join(visible_lines).strip() + '\\n', encoding='utf-8')\n",
+    encoding="utf-8",
+)
+prompt_target.chmod(0o700)
+
+tick_target = bin_dir / "loopx-pane-a2a-tick"
+tick_target.write_text(
+    "#!/usr/bin/env python3\n"
+    "import json, os, shlex, subprocess, sys\n"
+    "from pathlib import Path\n"
+    "loopx = os.environ.get('LOOPX_PANE_LOOPX') or str(Path(os.environ.get('LOOPX_PROJECT', '.')) / '.local' / 'bin' / 'loopx')\n"
+    "goal = os.environ.get('LOOPX_GOAL_ID', '').strip()\n"
+    "agent = os.environ.get('LOOPX_AGENT_ID', '').strip()\n"
+    "role = os.environ.get('LOOPX_ROLE_ID', '').strip() or os.environ.get('LOOPX_LANE_ID', '').strip() or agent\n"
+    "artifact_dir = Path(os.environ.get('LOOPX_PANE_ARTIFACT_DIR') or Path(os.environ.get('LOOPX_PROJECT', '.')) / '.local' / 'pane-artifacts' / (role or agent or 'lane'))\n"
+    "artifact_dir.mkdir(parents=True, exist_ok=True)\n"
+    "status_artifact = artifact_dir / 'pane-a2a-status.public.json'\n"
+    "check_records = []\n"
+    "def write_status_summary(*, ok, status, worker_label=None, worker_configured=False):\n"
+    "    payload = {\n"
+    "        'ok': bool(ok),\n"
+    "        'schema_version': 'pane_local_a2a_status_check_v0',\n"
+    "        'source': 'pane_local_a2a_status_check',\n"
+    "        'goal_id': goal,\n"
+    "        'agent_id': agent,\n"
+    "        'role_id': role,\n"
+    "        'coordination_model': 'decentralized_state_a2a',\n"
+    "        'workflow_driver': False,\n"
+    "        'status': status,\n"
+    "        'status_check_count': len(check_records),\n"
+    "        'worker_label': worker_label,\n"
+    "        'worker_configured': bool(worker_configured),\n"
+    "        'counts_as_research_round': False,\n"
+    "        'checks': check_records,\n"
+    "        'public_boundary': {\n"
+    "            'raw_logs_recorded': False,\n"
+    "            'private_artifacts_recorded': False,\n"
+    "            'absolute_paths_recorded': False,\n"
+    "            'credentials_recorded': False,\n"
+    "            'local_workspace_path_redacted': True,\n"
+    "        },\n"
+    "    }\n"
+    "    status_artifact.write_text(json.dumps(payload, indent=2, sort_keys=True) + '\\n', encoding='utf-8')\n"
+    "if not goal or not agent:\n"
+    "    print('\\n[LoopX pane A2A]\\nmissing LOOPX_GOAL_ID or LOOPX_AGENT_ID; cannot read role-local frontier.\\n', flush=True)\n"
+    "    write_status_summary(ok=False, status='missing_goal_or_agent')\n"
+    "    raise SystemExit(2)\n"
+    "def run(args):\n"
+    "    print('\\n[LoopX pane A2A] ' + ' '.join(shlex.quote(str(arg)) for arg in args), flush=True)\n"
+    "    return subprocess.call([str(arg) for arg in args])\n"
+    "def parse_worker_payload(text):\n"
+    "    if not text:\n"
+    "        return {}\n"
+    "    try:\n"
+    "        payload = json.loads(text)\n"
+    "        return payload if isinstance(payload, dict) else {}\n"
+    "    except Exception:\n"
+    "        pass\n"
+    "    start = text.find('{')\n"
+    "    end = text.rfind('}')\n"
+    "    if start >= 0 and end > start:\n"
+    "        try:\n"
+    "            payload = json.loads(text[start:end + 1])\n"
+    "            return payload if isinstance(payload, dict) else {}\n"
+    "        except Exception:\n"
+    "            return {}\n"
+    "    return {}\n"
+    "def attach_worker_payload(check_record, payload):\n"
+    "    if not payload:\n"
+    "        return\n"
+    "    evaluation = payload.get('evaluation_summary') if isinstance(payload.get('evaluation_summary'), dict) else {}\n"
+    "    live = payload.get('live_evidence') if isinstance(payload.get('live_evidence'), dict) else {}\n"
+    "    for key in ('selected_todo_id', 'selected_action', 'role_id', 'dev_metric', 'holdout_metric'):\n"
+    "        if payload.get(key) is not None:\n"
+    "            check_record[key] = payload.get(key)\n"
+    "    append = payload.get('append') if isinstance(payload.get('append'), dict) else {}\n"
+    "    if append.get('appended_count') is not None:\n"
+    "        check_record['appended_count'] = append.get('appended_count')\n"
+    "    if payload.get('successor_todos'):\n"
+    "        check_record['successor_todo_declared'] = True\n"
+    "    if evaluation.get('claim_allowed') is not None:\n"
+    "        check_record['claim_allowed'] = bool(evaluation.get('claim_allowed'))\n"
+    "    if evaluation.get('holdout_improvement_count') is not None:\n"
+    "        check_record['holdout_improvement_count'] = evaluation.get('holdout_improvement_count')\n"
+    "    if live.get('written') is not None:\n"
+    "        check_record['live_evidence_written'] = bool(live.get('written'))\n"
+    "print(f'\\n[LoopX pane A2A] role={role} agent={agent}\\n', flush=True)\n"
+    "turn = os.environ.get('LOOPX_PANE_WORKER_TURN', '').strip()\n"
+    "loop = os.environ.get('LOOPX_PANE_WORKER_LOOP', '').strip()\n"
+    "command = turn or loop\n"
+    "if not command:\n"
+    "    status = run([loopx, '--format', 'markdown', 'quota', 'should-run', '--goal-id', goal, '--agent-id', agent])\n"
+    "    frontier_status = None\n"
+    "    if status == 0:\n"
+    "        frontier_status = run([loopx, '--format', 'markdown', 'auto-research', 'frontier', '--goal-id', goal, '--agent-id', agent])\n"
+    "    check_records.append({'check_index': 1, 'quota_status': status, 'frontier_status': frontier_status, 'worker_configured': False, 'worker_executed': False, 'worker_status': None})\n"
+    "    ok = status == 0 and frontier_status == 0\n"
+    "    write_status_summary(ok=ok, status='no_worker_command_configured' if ok else 'frontier_failed' if status == 0 else 'quota_failed')\n"
+    "    if status != 0:\n"
+    "        raise SystemExit(status)\n"
+    "    if frontier_status != 0:\n"
+    "        raise SystemExit(frontier_status)\n"
+    "    print('\\n[LoopX pane A2A]\\nNo automated worker-turn is configured. Use the quota/frontier above and your role profile to do real visible research, then write public-safe evidence/todos with $LOOPX_PANE_LOOPX. Do not treat this tick as research completion.\\n', flush=True)\n"
+    "    raise SystemExit(0)\n"
+    "label = 'worker-turn' if turn else 'worker-loop'\n"
+    "status = run([loopx, '--format', 'markdown', 'quota', 'should-run', '--goal-id', goal, '--agent-id', agent])\n"
+    "check_record = {'check_index': 1, 'quota_status': status, 'worker_label': label, 'worker_configured': True, 'worker_executed': False, 'worker_status': None}\n"
+    "check_records.append(check_record)\n"
+    "if status != 0:\n"
+    "    write_status_summary(ok=False, status='quota_failed', worker_label=label, worker_configured=True)\n"
+    "    raise SystemExit(status)\n"
+    "print(f'\\n[LoopX pane A2A {label}]\\n{command}\\n', flush=True)\n"
+    "worker_env = os.environ.copy()\n"
+    "worker_env['LOOPX_MACHINE_JSON'] = '1'\n"
+    "worker = subprocess.run(command, shell=True, executable=os.environ.get('SHELL') or '/bin/bash', capture_output=True, text=True, env=worker_env)\n"
+    "if worker.stdout:\n"
+    "    print(worker.stdout, end='' if worker.stdout.endswith('\\n') else '\\n', flush=True)\n"
+    "if worker.stderr:\n"
+    "    print(worker.stderr, end='' if worker.stderr.endswith('\\n') else '\\n', file=sys.stderr, flush=True)\n"
+    "result = worker.returncode\n"
+    "check_record['worker_executed'] = True\n"
+    "check_record['worker_status'] = result\n"
+    "attach_worker_payload(check_record, parse_worker_payload(worker.stdout))\n"
+    "write_status_summary(ok=result == 0, status='completed' if result == 0 else 'worker_failed', worker_label=label, worker_configured=True)\n"
+    "if result != 0:\n"
+    "    raise SystemExit(result)\n"
+    "raise SystemExit(0)\n",
+    encoding="utf-8",
+)
+tick_target.chmod(0o700)
+"""
+
+
+CODEX_TUI_EXEC_PY = r"""
+import json
+import os
+import subprocess
+from pathlib import Path
+
+codex = os.environ["LOOPX_CODEX_BIN"]
+project = os.environ["LOOPX_PROJECT"]
+reasoning_effort = os.environ["LOOPX_CODEX_REASONING_EFFORT"]
+
+args = [codex]
+if os.environ.get("LOOPX_CODEX_TRUST_WORKSPACE") == "1":
+    candidates = [project, os.path.realpath(project)]
+    git_root = subprocess.run(
+        ["git", "-C", project, "rev-parse", "--show-toplevel"],
+        check=False,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+    if git_root:
+        candidates.extend([git_root, os.path.realpath(git_root)])
+    seen = set()
+    for path in candidates:
+        if not path or path in seen:
+            continue
+        seen.add(path)
+        args.extend(["-c", f"projects.{json.dumps(path)}.trust_level=\"trusted\""])
+
+args.extend(["-c", f"model_reasoning_effort={reasoning_effort}", "-C", project])
+prompt_path = os.environ.get("LOOPX_CODEX_TUI_PROMPT_ARTIFACT")
+if prompt_path and os.environ.get("LOOPX_CODEX_INITIAL_PROMPT_ENABLED", "1") != "0":
+    try:
+        prompt = Path(prompt_path).read_text(encoding="utf-8").strip()
+    except Exception:
+        prompt = ""
+    if prompt:
+        args.append(prompt)
+os.execvp(codex, args)
+"""

loopx/control_plane/agents/multi_agent/visible_launch_policy.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import argparse
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Tuple
+
+from loopx.visible_multi_agent_launcher import wake_visible_multi_agent_panes
+
+
+@dataclass(frozen=True)
+class VisibleLaunchPolicy:
+    """Generic visible-launch decisions shared by product presets."""
+
+    launch_visible: bool
+    wake_visible_after_launch: bool
+    attach: bool
+
+
+VisibleLauncherCallback = Callable[[dict[str, object], Path, Optional[str], Path], dict[str, object]]
+VisibleLaunchExecutor = Callable[..., dict[str, object]]
+VisibleWorkspacePolicy = Callable[[Path], Tuple[Optional[str], bool, bool]]
+
+
+def resolve_visible_launch_policy(
+    args: argparse.Namespace,
+    *,
+    launch_visible: bool,
+    default_wake_allowed: bool,
+    default_attach_allowed: bool,
+    attach_wake_conflict_message: str | None = None,
+) -> VisibleLaunchPolicy:
+    """Resolve attach/wake policy without product-specific runner logic."""
+
+    no_attach = bool(getattr(args, "no_attach", False))
+    attach_requested = bool(getattr(args, "attach", False))
+    if no_attach and attach_requested:
+        raise ValueError("--attach cannot be combined with --no-attach")
+
+    wake_setting = getattr(args, "wake_visible_after_launch", None)
+    if wake_setting is True and attach_requested:
+        raise ValueError(
+            attach_wake_conflict_message
+            or "--attach cannot be combined with --wake-visible-after-launch"
+        )
+
+    wake = False
+    if launch_visible:
+        if wake_setting is True:
+            wake = True
+        elif default_wake_allowed:
+            wake = bool(wake_setting is not False and not attach_requested)
+
+    attach = bool(
+        attach_requested
+        or (
+            launch_visible
+            and default_attach_allowed
+            and not no_attach
+            and not wake
+        )
+    )
+    return VisibleLaunchPolicy(
+        launch_visible=bool(launch_visible),
+        wake_visible_after_launch=wake,
+        attach=attach,
+    )
+
+
+def resolve_codex_trust_workspace(
+    args: argparse.Namespace,
+    *,
+    launch_visible: bool,
+    default: bool,
+) -> bool:
+    """Resolve the optional Codex workspace trust default for visible launches."""
+
+    if not launch_visible:
+        return False
+    trust_setting = getattr(args, "codex_trust_workspace", None)
+    if trust_setting is None:
+        return bool(default)
+    return bool(trust_setting)
+
+
+def make_visible_launcher_callback(
+    *,
+    launch_visible: bool,
+    launch_executor: VisibleLaunchExecutor,
+    launcher: str,
+    tmux_bin: str,
+    cli_bin: str,
+    codex_bin: str,
+    attach: bool,
+    replace_existing: bool,
+    workspace_policy: VisibleWorkspacePolicy,
+    auto_wake: bool = False,
+    auto_wake_interval_seconds: float = 45.0,
+) -> VisibleLauncherCallback | None:
+    """Create the generic callback shape expected by visible demo runners."""
+
+    if not launch_visible:
+        return None
+
+    def visible_launcher(
+        payload: dict[str, object],
+        registry_path: Path,
+        runtime_root_arg: str | None,
+        default_workspace: Path,
+    ) -> dict[str, object]:
+        workspace, create_workspace, codex_trust_workspace = workspace_policy(
+            default_workspace
+        )
+        return launch_executor(
+            payload,
+            registry_path=registry_path,
+            runtime_root_arg=runtime_root_arg,
+            launcher=launcher,
+            tmux_bin=tmux_bin,
+            cli_bin=cli_bin,
+            codex_bin=codex_bin,
+            attach=attach,
+            replace_existing=replace_existing,
+            workspace=workspace,
+            create_workspace=create_workspace,
+            codex_trust_workspace=codex_trust_workspace,
+            auto_wake=auto_wake,
+            auto_wake_interval_seconds=auto_wake_interval_seconds,
+        )
+
+    return visible_launcher
+
+
+def make_visible_wake_callback(
+    *,
+    tmux_bin: str,
+) -> Callable[[str, list[str]], dict[str, object]]:
+    """Return a pane-local A2A wake callback for visible launcher integrations."""
+
+    def visible_wake(session: str, lanes: Iterable[str]) -> dict[str, object]:
+        return wake_visible_multi_agent_panes(
+            session_name=session,
+            tmux_bin=tmux_bin,
+            lanes=lanes,
+            execute=True,
+        )
+
+    return visible_wake