mation 0.1.0__tar.gz

mation-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,22 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v4
+
+      - name: Build
+        run: uv build
+
+      - name: Publish
+        run: uv publish
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}

mation-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+*.egg-info/

mation-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mation-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: mation
+Version: 0.1.0
+Summary: CC Worker orchestration CLI — adopt, monitor, and drive Claude Code agents via cmux
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: typer>=0.15.0

mation-0.1.0/README.md

@@ -0,0 +1,150 @@
+# mation
+
+CC Worker orchestration CLI — adopt, monitor, and drive Claude Code agents via [cmux](https://cmux.com).
+
+## The Three-Party System
+
+`mation` implements a relay system between three parties: **Human**, **Supervisor CC**, and **Worker CC**. At least one of them is always active — the system never stalls.
+
+```
+Worker stops → Daemon relays → Supervisor wakes up, evaluates, instructs Worker
+                                        → Worker works → stops → Daemon relays → ...
+
+All plans done → Supervisor notifies Human → Human decides: more plans or done
+```
+
+- **Worker** does the actual coding work. It doesn't know it's being managed.
+- **Supervisor** is the Human's agent. It evaluates Worker output, runs verification (by telling Worker to review/test), and drives plans forward.
+- **Human** sets the mission direction and makes final decisions. Only gets notified when Supervisor needs input.
+- **Daemon** is the relay — when Worker stops, it instantly notifies Supervisor. Pure event bridge, no decisions.
+
+The three never all idle at once. Worker stops → Supervisor picks up. Supervisor sends instruction → Worker picks up. Like monks taking turns ringing the bell.
+
+## Requirements
+
+- [cmux](https://cmux.com) with socket mode set to **Automation** (Settings → Socket Control Mode)
+- Python 3.12+
+- [uv](https://github.com/astral-sh/uv)
+- CC Stop hook configured (see [Setup](#setup))
+
+## Install
+
+```bash
+uv tool install .
+```
+
+## Setup
+
+Configure the CC Stop hook globally so `mation` knows when a Worker finishes responding:
+
+```json
+// ~/.claude/settings.json (or your cac env settings)
+{
+  "hooks": {
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ~/.mation/on-stop.sh"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Create the hook script:
+
+```bash
+mkdir -p ~/.mation
+cat > ~/.mation/on-stop.sh << 'EOF'
+#!/bin/bash
+INPUT=$(cat)
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id')
+echo "$INPUT" > ~/.mation/stop-${SESSION_ID}
+EOF
+chmod +x ~/.mation/on-stop.sh
+```
+
+## Quick start
+
+```bash
+# Start daemon (background)
+mation start
+
+# Set the mission goal
+mation prompt set "Implement chat read receipts"
+
+# Adopt a running CC worker
+# (get session name from worker's exit: claude --resume "xxx")
+mation adopt my-worker
+
+# Queue plans
+mation plan add "Create message_reads table" "Backend read API" "Frontend read status"
+
+# Daemon watches Worker. When Worker stops, Supervisor gets notified.
+# Supervisor evaluates, then instructs Worker:
+mation send "review your changes"
+mation send "run tests"
+mation send "fix the failing test"
+
+# Mark plan complete when satisfied
+mation plan done 1
+
+# Check progress
+mation status
+
+# Stop daemon
+mation stop
+
+# End mission
+mation done
+```
+
+## CLI Reference
+
+### Lifecycle
+| Command | Description |
+|---------|-------------|
+| `mation start [-f]` | Start daemon (default: background, `-f`: foreground) |
+| `mation stop` | Stop daemon |
+| `mation status` | Show mission status (JSON) |
+| `mation done` | End mission, clear all state |
+
+### Worker
+| Command | Description |
+|---------|-------------|
+| `mation adopt <session>` | Adopt a CC worker by session name |
+| `mation drop` | Release worker |
+| `mation send "msg"` | Send message to worker |
+| `mation kick` | Interrupt stuck worker + resume |
+
+### Plan
+| Command | Description |
+|---------|-------------|
+| `mation plan add "desc" [-w workflow]` | Add plans |
+| `mation plan ls` | List all plans |
+| `mation plan show <id>` | Show plan details |
+| `mation plan rm <id>` | Remove plan |
+| `mation plan move <id> --top/--before/--after` | Reorder plans |
+| `mation plan done <id>` | Mark plan complete |
+
+### Prompt & Config
+| Command | Description |
+|---------|-------------|
+| `mation prompt set "text"` | Set mission prompt |
+| `mation prompt show` | Show current prompt |
+| `mation set workflow "code,test,review"` | Change default workflow |
+
+## How it works
+
+1. **Worker detection**: `mation adopt` finds the CC process via `ps`, reads `CMUX_SURFACE_ID` from its environment, locates session JSONL by `customTitle`
+2. **Idle detection**: CC Stop hook writes a signal file when Worker finishes responding. Daemon polls for this file.
+3. **Communication**: JSON-RPC over cmux Unix socket (`surface.send_text`, `surface.send_key`)
+4. **Relay**: Daemon consumes the signal file and injects a notification message into Supervisor's terminal. Supervisor CC wakes up and decides what to do next.
+
+## License
+
+MIT

mation-0.1.0/mation/cli.py

@@ -0,0 +1,372 @@
+"""Mission CLI — CC Worker 托管与任务编排。"""
+
+from __future__ import annotations
+
+import json
+import os
+import signal
+import subprocess
+import sys
+from typing import Optional
+
+import typer
+
+from mation import cmux
+from mation.state import (
+    DEFAULT_WORKFLOW,
+    STATE_DIR,
+    add_plan,
+    delete_state,
+    find_plan,
+    load_state,
+    move_plan,
+    new_state,
+    remove_plan,
+    save_state,
+)
+from mation.worker import resolve_worker
+
+app = typer.Typer(help="CC Worker orchestration CLI")
+plan_app = typer.Typer(help="Plan 管理")
+prompt_app = typer.Typer(help="Mission prompt 管理")
+app.add_typer(plan_app, name="plan")
+app.add_typer(prompt_app, name="prompt")
+
+
+def _require_state() -> dict:
+    state = load_state()
+    if state is None:
+        typer.echo("没有活跃的 mation。先运行 mation start", err=True)
+        raise typer.Exit(1)
+    return state
+
+
+def _output(data: dict) -> None:
+    typer.echo(json.dumps(data, ensure_ascii=False, indent=2))
+
+
+def _is_daemon_running(state: dict) -> bool:
+    pid = state.get("daemon_pid")
+    if not pid:
+        return False
+    try:
+        os.kill(pid, 0)
+        return True
+    except (ProcessLookupError, TypeError):
+        return False
+
+
+# ── 生命周期 ────────────────────────────────────────────────
+
+
+@app.command()
+def start(
+    foreground: bool = typer.Option(False, "-f", "--foreground", help="前台运行"),
+    workflow: str = typer.Option(
+        ",".join(DEFAULT_WORKFLOW), "--workflow", "-w", help="默认 workflow，逗号分隔",
+    ),
+) -> None:
+    """启动 mation daemon。默认后台运行，-f 前台运行。"""
+    state = load_state()
+
+    if state is None:
+        surface = cmux.get_current_surface()
+        if not surface:
+            typer.echo("未检测到 CMUX_SURFACE_ID，请在 cmux 终端中运行", err=True)
+            raise typer.Exit(1)
+        wf = [s.strip() for s in workflow.split(",") if s.strip()]
+        state = new_state(surface, wf)
+        save_state(state)
+    elif _is_daemon_running(state):
+        typer.echo("Daemon 已在运行", err=True)
+        raise typer.Exit(1)
+
+    if foreground:
+        state["daemon_pid"] = os.getpid()
+        save_state(state)
+        _output({"ok": True, "daemon_pid": os.getpid(), "mode": "foreground"})
+        from mation.daemon import run_daemon
+        run_daemon()
+    else:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        log_file = open(STATE_DIR / "daemon.log", "a")
+        proc = subprocess.Popen(
+            [sys.executable, "-m", "mation.daemon_runner"],
+            stdout=log_file,
+            stderr=log_file,
+        )
+        state["daemon_pid"] = proc.pid
+        save_state(state)
+        _output({"ok": True, "daemon_pid": proc.pid, "mode": "background"})
+
+
+@app.command()
+def stop() -> None:
+    """停止 daemon。"""
+    state = _require_state()
+    daemon_pid = state.get("daemon_pid")
+    if daemon_pid:
+        try:
+            os.kill(daemon_pid, signal.SIGTERM)
+            _output({"ok": True, "stopped_pid": daemon_pid})
+        except (ProcessLookupError, TypeError):
+            _output({"ok": True, "message": "Daemon 已不在运行"})
+    else:
+        _output({"ok": True, "message": "没有 daemon"})
+    state["daemon_pid"] = None
+    save_state(state)
+
+
+@app.command()
+def status() -> None:
+    """查看当前 mation 状态。"""
+    state = _require_state()
+
+    plans_summary = []
+    for p in state["plans"]:
+        plans_summary.append({
+            "id": p["id"],
+            "status": p["status"],
+            "step": p.get("step"),
+            "workflow": ",".join(p["workflow"]) if isinstance(p["workflow"], list) else p["workflow"],
+            "desc": p["desc"],
+        })
+
+    done_count = sum(1 for p in state["plans"] if p["status"] == "done")
+    running_count = sum(1 for p in state["plans"] if p["status"] == "running")
+    pending_count = sum(1 for p in state["plans"] if p["status"] == "pending")
+
+    worker_info = None
+    session = state.get("worker_session")
+    if session:
+        info = resolve_worker(session)
+        worker_info = {
+            "session": session,
+            "running": info.running,
+            "pid": info.pid,
+            "surface_id": info.surface_id,
+        }
+
+    _output({
+        "mission_prompt": state.get("mission_prompt"),
+        "supervisor_surface": state["supervisor_surface"],
+        "daemon": {"pid": state.get("daemon_pid"), "running": _is_daemon_running(state)},
+        "worker": worker_info,
+        "plans": {"total": len(state["plans"]), "done": done_count, "running": running_count, "pending": pending_count},
+        "plan_list": plans_summary,
+    })
+
+
+@app.command()
+def done() -> None:
+    """结束 mation，清除所有状态。"""
+    state = _require_state()
+    daemon_pid = state.get("daemon_pid")
+    if daemon_pid:
+        try:
+            os.kill(daemon_pid, signal.SIGTERM)
+        except (ProcessLookupError, TypeError):
+            pass
+    delete_state()
+    _output({"ok": True, "message": "Mission 结束"})
+
+
+# ── Worker ──────────────────────────────────────────────────
+
+
+@app.command()
+def adopt(
+    session: str = typer.Argument(..., help="Worker 的 session name"),
+) -> None:
+    """托管一个 CC worker。"""
+    state = _require_state()
+
+    info = resolve_worker(session)
+    if not info.running:
+        typer.echo(f"未找到运行中的 session '{session}'", err=True)
+        raise typer.Exit(1)
+    if not info.jsonl_path:
+        typer.echo(f"session '{session}' 还没有交互记录，请先发一条消息再 adopt", err=True)
+        raise typer.Exit(1)
+
+    state["worker_session"] = session
+    state["worker_cache"] = {
+        "pid": info.pid,
+        "surface_id": info.surface_id,
+        "jsonl_path": str(info.jsonl_path),
+    }
+    save_state(state)
+    _output({"ok": True, "session": session, "pid": info.pid, "surface_id": info.surface_id, "jsonl": str(info.jsonl_path)})
+
+
+@app.command()
+def drop() -> None:
+    """取消托管。"""
+    state = _require_state()
+    session = state.get("worker_session")
+    state["worker_session"] = None
+    state["worker_cache"] = None
+    save_state(state)
+    _output({"ok": True, "released": session})
+
+
+@app.command()
+def send(message: str = typer.Argument(..., help="发给 worker 的消息")) -> None:
+    """给 worker 发一条消息。"""
+    state = _require_state()
+    session = state.get("worker_session")
+    if not session:
+        typer.echo("没有托管的 worker", err=True)
+        raise typer.Exit(1)
+    info = resolve_worker(session)
+    if not info.running or not info.surface_id:
+        typer.echo(f"Worker '{session}' 未运行", err=True)
+        raise typer.Exit(1)
+    cmux.send_text(info.surface_id, message)
+    _output({"ok": True, "sent_to": session, "hint": "不用等，Worker 完成后 daemon 会通知你"})
+
+
+@app.command()
+def kick() -> None:
+    """打断卡住的 worker 并让它继续。"""
+    state = _require_state()
+    session = state.get("worker_session")
+    if not session:
+        typer.echo("没有托管的 worker", err=True)
+        raise typer.Exit(1)
+    info = resolve_worker(session)
+    if not info.running or not info.surface_id:
+        typer.echo(f"Worker '{session}' 未运行", err=True)
+        raise typer.Exit(1)
+    cmux.send_escape(info.surface_id)
+    import time
+    time.sleep(1)
+    cmux.send_text(info.surface_id, "继续当前任务")
+    _output({"ok": True, "kicked": session, "hint": "不用等，Worker 完成后 daemon 会通知你"})
+
+
+# ── Plan ────────────────────────────────────────────────────
+
+
+@plan_app.command("add")
+def plan_add(
+    descriptions: list[str] = typer.Argument(..., help="Plan 描述（支持多个）"),
+    workflow: str = typer.Option(None, "--workflow", "-w", help="Workflow 覆盖"),
+    before: Optional[int] = typer.Option(None, "--before"),
+    after: Optional[int] = typer.Option(None, "--after"),
+) -> None:
+    """添加 plan。"""
+    state = _require_state()
+    wf = [s.strip() for s in workflow.split(",") if s.strip()] if workflow else None
+    added = []
+    for desc in descriptions:
+        plan = add_plan(state, desc, workflow=wf, before=before, after=after)
+        added.append({"id": plan["id"], "desc": plan["desc"]})
+        if before is not None or after is not None:
+            after = plan["id"]
+            before = None
+    save_state(state)
+    _output({"ok": True, "added": added})
+
+
+@plan_app.command("ls")
+def plan_ls() -> None:
+    """列出所有 plan。"""
+    state = _require_state()
+    plans = [{"id": p["id"], "status": p["status"], "step": p.get("step"),
+              "workflow": ",".join(p["workflow"]) if isinstance(p["workflow"], list) else p["workflow"],
+              "desc": p["desc"]} for p in state["plans"]]
+    _output({"plans": plans})
+
+
+@plan_app.command("show")
+def plan_show(plan_id: int = typer.Argument(...)) -> None:
+    """查看 plan 详情。"""
+    state = _require_state()
+    plan = find_plan(state, plan_id)
+    if not plan:
+        typer.echo(f"Plan #{plan_id} 不存在", err=True)
+        raise typer.Exit(1)
+    _output(plan)
+
+
+@plan_app.command("rm")
+def plan_rm(plan_id: int = typer.Argument(...)) -> None:
+    """删除 plan。"""
+    state = _require_state()
+    if not remove_plan(state, plan_id):
+        typer.echo(f"Plan #{plan_id} 不存在", err=True)
+        raise typer.Exit(1)
+    save_state(state)
+    _output({"ok": True, "removed": plan_id})
+
+
+@plan_app.command("move")
+def plan_move(
+    plan_id: int = typer.Argument(...),
+    top: bool = typer.Option(False, "--top"),
+    bottom: bool = typer.Option(False, "--bottom"),
+    before: Optional[int] = typer.Option(None, "--before"),
+    after: Optional[int] = typer.Option(None, "--after"),
+) -> None:
+    """调整 plan 顺序。"""
+    state = _require_state()
+    if not move_plan(state, plan_id, top=top, bottom=bottom, before=before, after=after):
+        typer.echo(f"Plan #{plan_id} 不存在", err=True)
+        raise typer.Exit(1)
+    save_state(state)
+    _output({"ok": True, "moved": plan_id})
+
+
+@plan_app.command("done")
+def plan_done(plan_id: int = typer.Argument(...)) -> None:
+    """手动标记 plan 完成。"""
+    state = _require_state()
+    plan = find_plan(state, plan_id)
+    if not plan:
+        typer.echo(f"Plan #{plan_id} 不存在", err=True)
+        raise typer.Exit(1)
+    plan["status"] = "done"
+    plan["step"] = None
+    save_state(state)
+    _output({"ok": True, "plan": plan_id, "status": "done"})
+
+
+# ── Prompt ──────────────────────────────────────────────────
+
+
+@prompt_app.command("show")
+def prompt_show() -> None:
+    """查看 mation prompt。"""
+    state = _require_state()
+    _output({"mission_prompt": state.get("mission_prompt")})
+
+
+@prompt_app.command("set")
+def prompt_set(text: str = typer.Argument(...)) -> None:
+    """设置 mation prompt。"""
+    state = _require_state()
+    state["mission_prompt"] = text
+    save_state(state)
+    _output({"ok": True, "mission_prompt": text})
+
+
+# ── Set ─────────────────────────────────────────────────────
+
+
+@app.command("set")
+def set_config(key: str = typer.Argument(...), value: str = typer.Argument(...)) -> None:
+    """修改 mation 配置。"""
+    state = _require_state()
+    if key == "workflow":
+        wf = [s.strip() for s in value.split(",") if s.strip()]
+        state["workflow"] = wf
+        save_state(state)
+        _output({"ok": True, "workflow": wf})
+    else:
+        typer.echo(f"未知配置项: {key}", err=True)
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

mation-0.1.0/mation/cmux.py

@@ -0,0 +1,52 @@
+"""cmux JSON-RPC socket 通信层。
+
+直连 Unix socket，不依赖 cmux CLI，任何进程都能用（需 automation 模式）。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import socket
+
+
+SOCKET_PATH = os.environ.get(
+    "CMUX_SOCKET_PATH",
+    os.path.expanduser("~/Library/Application Support/cmux/cmux.sock"),
+)
+
+
+def rpc(method: str, params: dict | None = None) -> dict:
+    payload = {"id": "mation", "method": method, "params": params or {}}
+    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
+        s.connect(SOCKET_PATH)
+        s.sendall(json.dumps(payload).encode() + b"\n")
+        s.settimeout(10)
+        data = s.recv(65536).decode()
+    resp = json.loads(data)
+    if not resp.get("ok"):
+        error = resp.get("error", {})
+        msg = error.get("message", str(error)) if isinstance(error, dict) else str(error)
+        raise RuntimeError(f"cmux {method}: {msg}")
+    return resp.get("result", {})
+
+
+def get_current_surface() -> str | None:
+    return os.environ.get("CMUX_SURFACE_ID")
+
+
+def send_text(surface_id: str, text: str) -> None:
+    rpc("surface.send_text", {"surface_id": surface_id, "text": text})
+    rpc("surface.send_key", {"surface_id": surface_id, "key": "enter"})
+
+
+def send_escape(surface_id: str) -> None:
+    rpc("surface.send_key", {"surface_id": surface_id, "key": "escape"})
+
+
+def ping() -> bool:
+    try:
+        rpc("system.ping")
+        return True
+    except Exception:
+        return False

mation-0.1.0/mation/daemon.py

@@ -0,0 +1,134 @@
+"""后台守护进程：事件接力 + 进度提醒。
+
+两个职责：
+1. Worker Stop 信号 → 通知 Supervisor（正常接力）
+2. 两者都停了 → 提醒 Supervisor 当前进度和剩余 plan（防遗忘）
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import signal
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+from mation import cmux
+from mation.state import STATE_DIR, load_state
+
+STATE_DIR.mkdir(parents=True, exist_ok=True)
+LOG_FILE = STATE_DIR / "daemon.log"
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [daemon] %(message)s",
+    handlers=[logging.FileHandler(LOG_FILE)],
+)
+log = logging.getLogger(__name__)
+
+POLL_INTERVAL = 2
+IDLE_REMIND_TIMEOUT = 120  # 两者都停了多久后提醒 supervisor
+
+
+def stop_file(session_id: str) -> Path:
+    return STATE_DIR / f"stop-{session_id}"
+
+
+def _get_worker_session_id(state: dict[str, Any]) -> str | None:
+    cache = state.get("worker_cache") or {}
+    jsonl = cache.get("jsonl_path", "")
+    if jsonl:
+        return Path(jsonl).stem
+    return state.get("worker_session")
+
+
+def _plan_summary(state: dict[str, Any]) -> str:
+    plans = state.get("plans", [])
+    if not plans:
+        return "没有 plan。"
+    done = sum(1 for p in plans if p["status"] == "done")
+    total = len(plans)
+    pending = [p for p in plans if p["status"] in ("pending", "running")]
+    summary = f"Plan 进度：{done}/{total} 完成。"
+    if pending:
+        next_plans = ", ".join(f"#{p['id']} {p['desc']}" for p in pending[:3])
+        summary += f" 待推进：{next_plans}"
+    return summary
+
+
+def notify_supervisor(state: dict[str, Any], message: str) -> None:
+    surface = state.get("supervisor_surface")
+    if not surface:
+        return
+    log.info(f"→ Supervisor: {message[:120]}")
+    try:
+        cmux.send_text(surface, message)
+    except RuntimeError as e:
+        log.error(f"Failed to notify supervisor: {e}")
+
+
+def run_daemon() -> None:
+    log.info("Daemon started (pid=%d)", os.getpid())
+
+    both_idle_since: float | None = None
+
+    def handle_signal(signum: int, frame: Any) -> None:
+        log.info("Daemon stopping")
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, handle_signal)
+    signal.signal(signal.SIGINT, handle_signal)
+
+    while True:
+        try:
+            state = load_state()
+            if state is None:
+                log.info("No active mation, exiting")
+                break
+
+            session = state.get("worker_session")
+            if not session:
+                time.sleep(POLL_INTERVAL)
+                continue
+
+            session_id = _get_worker_session_id(state)
+            if not session_id:
+                time.sleep(POLL_INTERVAL)
+                continue
+
+            sf = stop_file(session_id)
+
+            if sf.exists():
+                # Worker 停了 → 读信号 → 通知 Supervisor → 消费
+                try:
+                    stop_data = json.loads(sf.read_text())
+                    last_msg = stop_data.get("last_assistant_message", "")
+                except (json.JSONDecodeError, OSError):
+                    last_msg = ""
+
+                sf.unlink()
+                both_idle_since = None
+
+                summary = _plan_summary(state)
+                notify_supervisor(state, f"[Mation] Worker 停了。回复：{last_msg[:300]} --- {summary}")
+                log.info("Stop signal consumed, supervisor notified")
+
+            else:
+                # 没有 Stop 信号 → Worker 在忙或者两者都停了
+                # 如果 Worker 在忙，不需要提醒
+                # 如果两者都停了（一段时间没有 Stop 信号），提醒 Supervisor
+                if both_idle_since is None:
+                    both_idle_since = time.time()
+                elif time.time() - both_idle_since > IDLE_REMIND_TIMEOUT:
+                    summary = _plan_summary(state)
+                    notify_supervisor(state, f"[Mation] {IDLE_REMIND_TIMEOUT}s 没有活动。{summary}")
+                    log.info("Both idle, reminded supervisor")
+                    both_idle_since = time.time()
+
+        except Exception as e:
+            log.error(f"Daemon error: {e}")
+
+        time.sleep(POLL_INTERVAL)

mation-0.1.0/mation/daemon_runner.py

@@ -0,0 +1,6 @@
+"""Daemon 入口点，供 subprocess 调用。"""
+
+from mation.daemon import run_daemon
+
+if __name__ == "__main__":
+    run_daemon()

mation-0.1.0/mation/prompt.py

@@ -0,0 +1,39 @@
+"""Prompt 拼接逻辑。"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from mation.state import load_config
+
+
+def build_message(
+    state: dict[str, Any],
+    plan: dict[str, Any],
+    step_name: str,
+) -> str:
+    """根据 mission prompt + plan/step 拼接最终发给 worker 的消息。"""
+    config = load_config()
+    step_prompts = config.get("step_prompts", {})
+    mission_prompt = state.get("mission_prompt") or ""
+
+    step_prompt = step_prompts.get(step_name)
+
+    # slash command 不拼接 mission prompt
+    if step_prompt and step_prompt.startswith("/"):
+        return step_prompt
+
+    parts: list[str] = []
+
+    if mission_prompt:
+        parts.append(mission_prompt)
+        parts.append("---")
+
+    if step_name == "code" or step_prompt is None:
+        # code 步骤：发 plan 描述
+        parts.append(plan["desc"])
+    else:
+        parts.append(step_prompt)
+
+    # 单行拼接，避免 CC TUI 多行输入模式（多行时 enter 变换行不提交）
+    return " --- ".join(parts)

mation-0.1.0/mation/state.py

@@ -0,0 +1,142 @@
+"""Mation 状态持久化。读写 ~/.mation/active.json"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+STATE_DIR = Path.home() / ".mation"
+STATE_FILE = STATE_DIR / "active.json"
+CONFIG_FILE = STATE_DIR / "config.json"
+
+DEFAULT_WORKFLOW = ["code", "test", "simplify", "review", "fix"]
+DEFAULT_STEP_PROMPTS: dict[str, str | None] = {
+    "code": None,
+    "test": "对你刚才的改动跑测试，修复失败的用例",
+    "simplify": "/simplify",
+    "review": "/review",
+    "fix": "修复 review 中发现的问题",
+}
+
+
+def _ensure_dir() -> None:
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_state() -> dict[str, Any] | None:
+    if not STATE_FILE.exists():
+        return None
+    return json.loads(STATE_FILE.read_text())
+
+
+def save_state(state: dict[str, Any]) -> None:
+    _ensure_dir()
+    STATE_FILE.write_text(json.dumps(state, ensure_ascii=False, indent=2))
+
+
+def delete_state() -> None:
+    if STATE_FILE.exists():
+        STATE_FILE.unlink()
+
+
+def load_config() -> dict[str, Any]:
+    if not CONFIG_FILE.exists():
+        return {"step_prompts": dict(DEFAULT_STEP_PROMPTS)}
+    return json.loads(CONFIG_FILE.read_text())
+
+
+def save_config(config: dict[str, Any]) -> None:
+    _ensure_dir()
+    CONFIG_FILE.write_text(json.dumps(config, ensure_ascii=False, indent=2))
+
+
+def new_state(supervisor_surface: str, workflow: list[str]) -> dict[str, Any]:
+    return {
+        "supervisor_surface": supervisor_surface,
+        "worker_session": None,
+        "worker_cache": None,
+        "daemon_pid": None,
+        "workflow": workflow,
+        "mission_prompt": None,
+        "plans": [],
+        "next_plan_id": 1,
+    }
+
+
+def add_plan(
+    state: dict[str, Any],
+    desc: str,
+    workflow: list[str] | None = None,
+    before: int | None = None,
+    after: int | None = None,
+) -> dict[str, Any]:
+    plan = {
+        "id": state["next_plan_id"],
+        "desc": desc,
+        "workflow": workflow or state["workflow"],
+        "status": "pending",
+        "step": None,
+        "step_index": 0,
+    }
+    state["next_plan_id"] += 1
+
+    plans = state["plans"]
+    if before is not None:
+        idx = next((i for i, p in enumerate(plans) if p["id"] == before), None)
+        if idx is not None:
+            plans.insert(idx, plan)
+        else:
+            plans.append(plan)
+    elif after is not None:
+        idx = next((i for i, p in enumerate(plans) if p["id"] == after), None)
+        if idx is not None:
+            plans.insert(idx + 1, plan)
+        else:
+            plans.append(plan)
+    else:
+        plans.append(plan)
+
+    return plan
+
+
+def find_plan(state: dict[str, Any], plan_id: int) -> dict[str, Any] | None:
+    return next((p for p in state["plans"] if p["id"] == plan_id), None)
+
+
+def move_plan(
+    state: dict[str, Any],
+    plan_id: int,
+    *,
+    top: bool = False,
+    bottom: bool = False,
+    before: int | None = None,
+    after: int | None = None,
+) -> bool:
+    plans = state["plans"]
+    idx = next((i for i, p in enumerate(plans) if p["id"] == plan_id), None)
+    if idx is None:
+        return False
+
+    plan = plans.pop(idx)
+
+    if top:
+        plans.insert(0, plan)
+    elif bottom:
+        plans.append(plan)
+    elif before is not None:
+        target_idx = next((i for i, p in enumerate(plans) if p["id"] == before), len(plans))
+        plans.insert(target_idx, plan)
+    elif after is not None:
+        target_idx = next((i for i, p in enumerate(plans) if p["id"] == after), len(plans) - 1)
+        plans.insert(target_idx + 1, plan)
+    else:
+        plans.append(plan)
+
+    return True
+
+
+def remove_plan(state: dict[str, Any], plan_id: int) -> bool:
+    before_len = len(state["plans"])
+    state["plans"] = [p for p in state["plans"] if p["id"] != plan_id]
+    return len(state["plans"]) < before_len

mation-0.1.0/mation/worker.py

@@ -0,0 +1,217 @@
+"""Worker 解析：从 session name 查找运行时信息（PID、workspace、surface、JSONL 路径）。
+
+查找链路：
+  session name → ps 找 "claude.*<session>" → PID
+  PID → ps eww 读环境变量 → CMUX_WORKSPACE_ID, CMUX_SURFACE_ID
+  session name → JSONL 目录匹配文件名
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class WorkerInfo:
+    session: str
+    pid: int | None = None
+    workspace_id: str | None = None  # cmux UUID
+    surface_id: str | None = None  # cmux UUID
+    jsonl_path: Path | None = None
+    running: bool = False
+
+
+def _find_claude_pid(session: str) -> int | None:
+    """从 ps 找到 claude --resume <session> 的实际二进制 PID（跳过 bash wrapper）。"""
+    try:
+        result = subprocess.run(
+            ["ps", "-eo", "pid,args"],
+            capture_output=True, text=True, timeout=5,
+        )
+    except Exception:
+        return None
+
+    candidates: list[tuple[int, str]] = []
+    for line in result.stdout.strip().split("\n"):
+        line = line.strip()
+        if "claude" not in line:
+            continue
+        # 匹配 --resume <session> 或 --name <session>
+        matched = False
+        for flag in ("--resume", "--name"):
+            if f"{flag} {session}" in line or f'{flag} "{session}"' in line:
+                matched = True
+                break
+        if not matched:
+            continue
+        parts = line.split()
+        try:
+            pid = int(parts[0])
+            args = " ".join(parts[1:])
+            candidates.append((pid, args))
+        except (ValueError, IndexError):
+            pass
+
+    if not candidates:
+        return None
+
+    # 优先选非 bash wrapper 的进程（实际二进制）
+    for pid, args in candidates:
+        if "bash" not in args:
+            return pid
+
+    # fallback：返回第一个
+    return candidates[0][0]
+
+
+def _read_env_from_pid(pid: int, var: str) -> str | None:
+    """从进程环境变量读取指定变量（macOS ps eww）。"""
+    try:
+        result = subprocess.run(
+            ["ps", "eww", "-p", str(pid)],
+            capture_output=True, text=True, timeout=5,
+        )
+    except Exception:
+        return None
+
+    for token in result.stdout.replace("\n", " ").split(" "):
+        if token.startswith(f"{var}="):
+            return token.split("=", 1)[1]
+    return None
+
+
+def _find_jsonl(session: str) -> Path | None:
+    """在 .cac 和 .claude 目录下找 session 对应的 JSONL 文件。
+
+    session 可以是 UUID（直接匹配文件名）或 display name（从 customTitle 匹配）。
+    """
+    search_dirs = [
+        Path.home() / ".cac" / "envs" / "main" / ".claude" / "projects",
+        Path.home() / ".claude" / "projects",
+    ]
+
+    for search_dir in search_dirs:
+        if not search_dir.exists():
+            continue
+
+        # 1. 直接匹配 UUID 文件名
+        for jsonl_path in search_dir.rglob(f"{session}.jsonl"):
+            return jsonl_path
+
+        # 2. 按 customTitle 匹配（session name 不是 UUID 的情况）
+        for jsonl_path in search_dir.rglob("*.jsonl"):
+            try:
+                with open(jsonl_path) as f:
+                    first_line = f.readline()
+                if not first_line:
+                    continue
+                entry = json.loads(first_line)
+                if entry.get("type") == "custom-title" and entry.get("customTitle") == session:
+                    return jsonl_path
+            except (json.JSONDecodeError, OSError):
+                continue
+
+    return None
+
+
+def resolve_worker(session: str) -> WorkerInfo:
+    """解析 worker 的完整运行时信息。"""
+    info = WorkerInfo(session=session)
+
+    # 1. 找 PID
+    pid = _find_claude_pid(session)
+    if pid is None:
+        info.running = False
+        # 仍然尝试找 JSONL（进程可能已退出但文件还在）
+        info.jsonl_path = _find_jsonl(session)
+        return info
+
+    info.pid = pid
+    info.running = True
+
+    # 2. 从 PID 读 cmux 信息
+    info.workspace_id = _read_env_from_pid(pid, "CMUX_WORKSPACE_ID")
+    info.surface_id = _read_env_from_pid(pid, "CMUX_SURFACE_ID")
+
+    # 3. 找 JSONL
+    info.jsonl_path = _find_jsonl(session)
+
+    return info
+
+
+def get_worker_state_from_jsonl(jsonl_path: Path) -> dict:
+    """从 JSONL 读取 worker 最新状态。
+
+    返回:
+        {"status": "idle"|"busy"|"interrupted"|"unknown",
+         "last_type": str, "last_timestamp": str, "last_text": str}
+    """
+    if not jsonl_path.exists():
+        return {"status": "unknown"}
+
+    # 读最后几行
+    try:
+        lines = jsonl_path.read_text().strip().split("\n")
+    except Exception:
+        return {"status": "unknown"}
+
+    if not lines:
+        return {"status": "unknown"}
+
+    # 从后往前找最近的真实 user/assistant 消息（跳过 local command）
+    last_entry = None
+    for line in reversed(lines[-50:]):
+        try:
+            entry = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        entry_type = entry.get("type")
+
+        if entry_type == "assistant":
+            last_entry = entry
+            break
+
+        if entry_type == "user":
+            # 跳过 local command（/model, /clear 等）
+            content = entry.get("message", {}).get("content", "")
+            content_str = str(content)
+            if "<command-name>" in content_str or "<local-command" in content_str:
+                continue
+            last_entry = entry
+            break
+
+    if last_entry is None:
+        return {"status": "unknown"}
+
+    entry_type = last_entry["type"]
+    timestamp = last_entry.get("timestamp", "")
+
+    if entry_type == "assistant":
+        # 最后一条是 assistant 回复 → idle
+        content = last_entry.get("message", {}).get("content", "")
+        text = ""
+        if isinstance(content, list):
+            for c in content:
+                if c.get("type") == "text":
+                    text = c["text"][:200]
+                    break
+        else:
+            text = str(content)[:200]
+
+        return {"status": "idle", "last_type": "assistant", "last_timestamp": timestamp, "last_text": text}
+
+    elif entry_type == "user":
+        content = last_entry.get("message", {}).get("content", "")
+        # 检查是否是中断
+        if isinstance(content, list):
+            for c in content:
+                if isinstance(c, dict) and "Request interrupted" in str(c.get("text", "")):
+                    return {"status": "interrupted", "last_type": "user", "last_timestamp": timestamp, "last_text": "interrupted"}
+
+        return {"status": "busy", "last_type": "user", "last_timestamp": timestamp, "last_text": ""}
+
+    return {"status": "unknown"}

mation-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "mation"
+version = "0.1.0"
+description = "CC Worker orchestration CLI — adopt, monitor, and drive Claude Code agents via cmux"
+requires-python = ">=3.12"
+dependencies = [
+    "typer>=0.15.0",
+]
+
+[project.scripts]
+mation = "mation.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["mation"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"