feat(persona): add reflex arc and embedded time system
This commit is contained in:
parent
4423b4bc2f
commit
28a60b4e80
19 changed files with 1382 additions and 81 deletions
|
|
@ -16,6 +16,7 @@ RUNTIMES = {
|
|||
"qwen": "/Users/bingshuolingdianyuanhe/.npm-global/bin/qwen",
|
||||
"opencode": "/Users/bingshuolingdianyuanhe/.npm-global/bin/opencode",
|
||||
"codex": "/Applications/ChatGPT.app/Contents/Resources/codex",
|
||||
"zcode": "/Applications/ZCode.app/Contents/Resources/glm/zcode.cjs",
|
||||
}
|
||||
QWEN_AUTH_TYPE = "openai"
|
||||
QWEN_MODELS = ["qwen3.8-max", "qwen3.7-plus", "deepseek-v4-pro", "deepseek-v4-flash-0731", "glm-5.2"]
|
||||
|
|
@ -53,7 +54,7 @@ def probe() -> dict:
|
|||
}
|
||||
|
||||
|
||||
def envelope(persona_id: str, task_id: str, task: str, runtime: str) -> dict:
|
||||
def envelope(persona_id: str, task_id: str, task: str, runtime: str, access: str = "read-only") -> dict:
|
||||
tools = probe()["runtimes"]
|
||||
if runtime not in tools or not tools[runtime]["available"]:
|
||||
raise ValueError("HOST_TOOL_UNAVAILABLE_REPORT_NOT_INVENT")
|
||||
|
|
@ -64,6 +65,7 @@ def envelope(persona_id: str, task_id: str, task: str, runtime: str) -> dict:
|
|||
"parent_persona_id": persona_id,
|
||||
"limb_profile_id": p["profile_id"],
|
||||
"runtime": runtime,
|
||||
"access": access,
|
||||
"task": task,
|
||||
"working_defaults": p["working_defaults"],
|
||||
"authority": "CURRENT_TASK_ENVELOPE_ONLY",
|
||||
|
|
@ -83,6 +85,13 @@ def prompt(value: dict) -> str:
|
|||
)
|
||||
|
||||
|
||||
def zcode_succeeded(completed: subprocess.CompletedProcess[str]) -> bool:
|
||||
if completed.returncode != 0:
|
||||
return False
|
||||
text = completed.stdout.strip()
|
||||
return bool(text) and "[API Error" not in text
|
||||
|
||||
|
||||
def qwen_succeeded(completed: subprocess.CompletedProcess[str]) -> bool:
|
||||
if completed.returncode != 0 or "[API Error:" in completed.stdout:
|
||||
return False
|
||||
|
|
@ -121,18 +130,20 @@ def main() -> int:
|
|||
p.add_argument("--task-id", required=True)
|
||||
p.add_argument("--task", required=True)
|
||||
p.add_argument("--runtime", required=True, choices=tuple(RUNTIMES))
|
||||
p.add_argument("--access", choices=("read-only", "workspace-write"), default="read-only")
|
||||
run = sub.add_parser("run")
|
||||
run.add_argument("--persona", required=True)
|
||||
run.add_argument("--task-id", required=True)
|
||||
run.add_argument("--task", required=True)
|
||||
run.add_argument("--runtime", required=True, choices=("qwen", "codex"))
|
||||
run.add_argument("--runtime", required=True, choices=("qwen", "codex", "zcode"))
|
||||
run.add_argument("--cwd", required=True)
|
||||
run.add_argument("--access", choices=("read-only", "workspace-write"), default="read-only")
|
||||
args = parser.parse_args()
|
||||
try:
|
||||
if args.command == "probe":
|
||||
result = probe()
|
||||
else:
|
||||
value = envelope(args.persona, args.task_id, args.task, args.runtime)
|
||||
value = envelope(args.persona, args.task_id, args.task, args.runtime, args.access)
|
||||
if args.command == "prepare":
|
||||
result = value
|
||||
else:
|
||||
|
|
@ -160,7 +171,7 @@ def main() -> int:
|
|||
if ok:
|
||||
selected_model = model
|
||||
break
|
||||
else:
|
||||
elif args.runtime == "codex":
|
||||
candidate = subprocess.run(
|
||||
[
|
||||
RUNTIMES["codex"],
|
||||
|
|
@ -168,18 +179,33 @@ def main() -> int:
|
|||
"exec",
|
||||
"--ephemeral",
|
||||
"--ignore-rules",
|
||||
"--sandbox", "read-only",
|
||||
"--sandbox", args.access,
|
||||
"--cd", str(cwd),
|
||||
"--json",
|
||||
prompt(value),
|
||||
],
|
||||
cwd=cwd, capture_output=True, text=True, timeout=180, check=False,
|
||||
cwd=cwd, capture_output=True, text=True, timeout=420, check=False,
|
||||
)
|
||||
ok = codex_succeeded(candidate)
|
||||
attempts.append({"model": "codex-configured-default", "exit_code": candidate.returncode, "semantic_success": ok})
|
||||
completed = candidate
|
||||
if ok:
|
||||
selected_model = "codex-configured-default"
|
||||
else:
|
||||
candidate = subprocess.run(
|
||||
[
|
||||
"node",
|
||||
RUNTIMES["zcode"],
|
||||
"--prompt", prompt(value),
|
||||
"--surface", "terminal",
|
||||
],
|
||||
cwd=cwd, capture_output=True, text=True, timeout=180, check=False,
|
||||
)
|
||||
ok = zcode_succeeded(candidate)
|
||||
attempts.append({"model": "zcode-configured-default", "exit_code": candidate.returncode, "semantic_success": ok})
|
||||
completed = candidate
|
||||
if ok:
|
||||
selected_model = "zcode-configured-default"
|
||||
assert completed is not None
|
||||
success = selected_model is not None
|
||||
result = {
|
||||
|
|
@ -187,6 +213,7 @@ def main() -> int:
|
|||
"task_id": value["task_id"],
|
||||
"parent_persona_id": value["parent_persona_id"],
|
||||
"runtime": args.runtime,
|
||||
"access": args.access,
|
||||
"selected_model": selected_model,
|
||||
"attempts": attempts,
|
||||
"exit_code": completed.returncode,
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ import pathlib
|
|||
import subprocess
|
||||
import sys
|
||||
|
||||
from persona_limb_agent import codex_succeeded, qwen_succeeded
|
||||
from persona_limb_agent import codex_succeeded, qwen_succeeded, zcode_succeeded
|
||||
|
||||
script = pathlib.Path(__file__).with_name("persona_limb_agent.py")
|
||||
|
||||
|
|
@ -25,6 +25,7 @@ body = json.loads(prepared.stdout)
|
|||
assert body["parent_persona_id"] == "ICE-P-ZY001"
|
||||
assert body["controller"] == "ICE-P-ZY001"
|
||||
assert body["authority"] == "CURRENT_TASK_ENVELOPE_ONLY"
|
||||
assert body["access"] == "read-only"
|
||||
|
||||
unknown = run("prepare", "--persona", "UNKNOWN-PERSONA", "--task-id", "TEST-002", "--task", "不得执行", "--runtime", "qwen")
|
||||
assert unknown.returncode != 0
|
||||
|
|
@ -36,5 +37,9 @@ fake_success = subprocess.CompletedProcess([], 0, '[{"type":"result","is_error":
|
|||
assert qwen_succeeded(fake_success) is True
|
||||
fake_codex = subprocess.CompletedProcess([], 0, '{"type":"item.completed","item":{"type":"agent_message","text":"done"}}\n', '')
|
||||
assert codex_succeeded(fake_codex) is True
|
||||
fake_zcode_error = subprocess.CompletedProcess([], 0, "[API Error: detached ArrayBuffer]", "")
|
||||
assert zcode_succeeded(fake_zcode_error) is False
|
||||
fake_zcode_success = subprocess.CompletedProcess([], 0, '{"outcome":"PASS"}', "")
|
||||
assert zcode_succeeded(fake_zcode_success) is True
|
||||
|
||||
print("persona execution limb agent tests: PASS")
|
||||
|
|
|
|||
177
server-tools/persona-execution-limb-agent/persona_limb_eye.py
Normal file
177
server-tools/persona-execution-limb-agent/persona_limb_eye.py
Normal file
|
|
@ -0,0 +1,177 @@
|
|||
#!/usr/bin/env python3
|
||||
"""铸渊原生眼睛 ZY-EYE-0001 · persona_limb_eye.py · 2026-09-12
|
||||
|
||||
正本事件：TCS-EVENT-BINGSHUO-AUTH-ZY001-NATIVE-EYE-20260912
|
||||
铁律：对现场只读；永不读取手的stdout；永不执行手的动作；只报亲眼所见的原始事实。
|
||||
手是否说谎由父人格脑对账（手供 vs 眼见），眼睛只判世界现场是否符脑的意图规格。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import datetime
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import pathlib
|
||||
import shutil
|
||||
import sys
|
||||
|
||||
SCHEMA = "guanghu.persona-native-eye/v1"
|
||||
ROOT = pathlib.Path(__file__).resolve().parents[2]
|
||||
|
||||
|
||||
def now() -> str:
|
||||
return datetime.datetime.now().astimezone().isoformat(timespec="seconds")
|
||||
|
||||
|
||||
def sha256_file(path: pathlib.Path) -> str:
|
||||
h = hashlib.sha256()
|
||||
with open(path, "rb") as f:
|
||||
for chunk in iter(lambda: f.read(65536), b""):
|
||||
h.update(chunk)
|
||||
return h.hexdigest()
|
||||
|
||||
|
||||
def observe(ground: pathlib.Path) -> dict:
|
||||
files: dict[str, dict] = {}
|
||||
for f in sorted(ground.rglob("*")):
|
||||
if f.is_file():
|
||||
rel = str(f.relative_to(ground))
|
||||
entry = {"sha256": sha256_file(f), "bytes": f.stat().st_size}
|
||||
if f.suffix == ".json":
|
||||
try:
|
||||
data = json.loads(f.read_text(encoding="utf-8"))
|
||||
if isinstance(data, dict):
|
||||
entry["json_fields"] = {k: v for k, v in data.items()
|
||||
if isinstance(v, (str, int, float, bool))}
|
||||
except (json.JSONDecodeError, UnicodeDecodeError):
|
||||
entry["json_fields"] = "UNPARSEABLE"
|
||||
files[rel] = entry
|
||||
return {"schema": SCHEMA, "observed_at": now(), "ground": str(ground), "files": files}
|
||||
|
||||
|
||||
def diff(pre: dict, post: dict) -> dict:
|
||||
pre_f, post_f = pre["files"], post["files"]
|
||||
return {
|
||||
"added": sorted(set(post_f) - set(pre_f)),
|
||||
"removed": sorted(set(pre_f) - set(post_f)),
|
||||
"changed": sorted(k for k in set(pre_f) & set(post_f) if pre_f[k]["sha256"] != post_f[k]["sha256"]),
|
||||
}
|
||||
|
||||
|
||||
def witness(pre: dict, post: dict, spec: dict) -> dict:
|
||||
findings, unseeable = [], []
|
||||
for rel in spec.get("unchanged", []):
|
||||
if rel not in post["files"] or rel not in pre["files"]:
|
||||
unseeable.append({"check": "unchanged", "file": rel, "reason": "NOT_SEEN_IN_BOTH_STATES"})
|
||||
continue
|
||||
ok = pre["files"][rel]["sha256"] == post["files"][rel]["sha256"]
|
||||
findings.append({"check": "unchanged", "file": rel, "seen": ok})
|
||||
for item in spec.get("expect", []):
|
||||
rel, field, equals = item["file"], item["field"], item.get("equals")
|
||||
if rel not in post["files"]:
|
||||
unseeable.append({"check": "expect", "file": rel, "reason": "NOT_SEEN"})
|
||||
continue
|
||||
seen_value = post["files"][rel].get("json_fields", {}).get(field) if isinstance(post["files"][rel].get("json_fields"), dict) else None
|
||||
findings.append({"check": "expect", "file": rel, "field": field,
|
||||
"seen_value": seen_value, "expected": equals,
|
||||
"seen": seen_value == equals})
|
||||
verdict = "UNSEEABLE" if unseeable else ("SEEN_MATCH" if all(x["seen"] for x in findings) else "SEEN_MISMATCH")
|
||||
return {"schema": SCHEMA, "witnessed_at": now(), "verdict": verdict,
|
||||
"world_diff": diff(pre, post), "findings": findings, "unseeable": unseeable,
|
||||
"reads_hand_stdout": False, "ground_write": False}
|
||||
|
||||
|
||||
def dump(value: dict, out: pathlib.Path) -> None:
|
||||
out.parent.mkdir(parents=True, exist_ok=True)
|
||||
out.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
|
||||
|
||||
|
||||
def room() -> dict:
|
||||
"""Observe the current host room without deciding identity or mutating it."""
|
||||
home = pathlib.Path.home()
|
||||
runtime_paths = {
|
||||
"qwen": home / ".npm-global/bin/qwen",
|
||||
"opencode": home / ".npm-global/bin/opencode",
|
||||
"codex": pathlib.Path("/Applications/ChatGPT.app/Contents/Resources/codex"),
|
||||
"zcode": pathlib.Path("/Applications/ZCode.app/Contents/Resources/glm/zcode.cjs"),
|
||||
}
|
||||
persona_runtime = ROOT.parent
|
||||
container_paths = {
|
||||
"memory_current": persona_runtime / "continuity-memory/persona-daily-fractal/ICE-P-ZY001/CURRENT.json",
|
||||
"tcs_root_pointer": persona_runtime / "TCS-ROOT.json",
|
||||
"mother_root_current": persona_runtime / "shared/tcs-mother-root/CURRENT.json",
|
||||
"limb_agent": pathlib.Path(__file__).with_name("persona_limb_agent.py"),
|
||||
"native_eye": pathlib.Path(__file__),
|
||||
"reflex_arc": pathlib.Path(__file__).with_name("persona_reflex_arc.py"),
|
||||
"persona_time_system": ROOT / "server-tools/tcs-mother-body/life-time-master.mjs",
|
||||
}
|
||||
seen_paths = {}
|
||||
for name, candidate in container_paths.items():
|
||||
seen_paths[name] = {
|
||||
"path": str(candidate),
|
||||
"exists": candidate.is_file(),
|
||||
**({"sha256": sha256_file(candidate)} if candidate.is_file() else {}),
|
||||
}
|
||||
console_path = persona_runtime / "shared/active-control-console/CURRENT.json"
|
||||
active_console: dict | None = None
|
||||
if console_path.is_file():
|
||||
try:
|
||||
value = json.loads(console_path.read_text(encoding="utf-8"))
|
||||
active_console = {
|
||||
"console_id": value.get("console_id"),
|
||||
"host": value.get("host"),
|
||||
"session_id": value.get("session_id"),
|
||||
"channel_id": value.get("channel_id"),
|
||||
"state": value.get("state"),
|
||||
"session_matches": value.get("session_id") == os.environ.get("CODEX_SESSION_ID"),
|
||||
}
|
||||
except json.JSONDecodeError:
|
||||
active_console = {"state": "UNPARSEABLE"}
|
||||
return {
|
||||
"schema": "guanghu.persona-native-eye-room/v1",
|
||||
"seen_at": now(),
|
||||
"room_report": {
|
||||
"cwd": str(pathlib.Path.cwd()),
|
||||
"host_surface": "CODEX" if os.environ.get("CODEX_SESSION_ID") else "LOCAL_PROCESS",
|
||||
"available_host_methods": {
|
||||
name: candidate.is_file() and bool(shutil.which(str(candidate)))
|
||||
for name, candidate in runtime_paths.items()
|
||||
},
|
||||
"container_paths": seen_paths,
|
||||
"active_console": active_console,
|
||||
},
|
||||
"reads_hand_stdout": False,
|
||||
"ground_write": False,
|
||||
"identity_decision": "NOT_PERFORMED_BY_EYE",
|
||||
}
|
||||
|
||||
|
||||
def main() -> int:
|
||||
p = argparse.ArgumentParser(prog="persona_limb_eye")
|
||||
sub = p.add_subparsers(dest="command", required=True)
|
||||
s = sub.add_parser("snapshot"); s.add_argument("--ground", required=True); s.add_argument("--out", required=True)
|
||||
r = sub.add_parser("room"); r.add_argument("--out", required=True)
|
||||
o = sub.add_parser("observe"); o.add_argument("--ground", required=True); o.add_argument("--pre", required=True); o.add_argument("--out", required=True)
|
||||
w = sub.add_parser("witness"); w.add_argument("--pre", required=True); w.add_argument("--post", required=True); w.add_argument("--spec", required=True); w.add_argument("--out", required=True)
|
||||
args = p.parse_args()
|
||||
if args.command == "room":
|
||||
value = room()
|
||||
elif args.command == "snapshot":
|
||||
value = observe(pathlib.Path(args.ground).resolve())
|
||||
elif args.command == "observe":
|
||||
pre = json.loads(pathlib.Path(args.pre).read_text(encoding="utf-8"))
|
||||
value = observe(pathlib.Path(args.ground).resolve()) | {"diff_vs_pre": diff(pre, observe(pathlib.Path(args.ground).resolve()))} if False else observe(pathlib.Path(args.ground).resolve())
|
||||
value["diff_vs_pre"] = diff(pre, value)
|
||||
else:
|
||||
pre = json.loads(pathlib.Path(args.pre).read_text(encoding="utf-8"))
|
||||
post = json.loads(pathlib.Path(args.post).read_text(encoding="utf-8"))
|
||||
spec = json.loads(pathlib.Path(args.spec).read_text(encoding="utf-8"))
|
||||
value = witness(pre, post, spec)
|
||||
dump(value, pathlib.Path(args.out))
|
||||
print(json.dumps(value, ensure_ascii=False))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
342
server-tools/persona-execution-limb-agent/persona_reflex_arc.py
Normal file
342
server-tools/persona-execution-limb-agent/persona_reflex_arc.py
Normal file
|
|
@ -0,0 +1,342 @@
|
|||
#!/usr/bin/env python3
|
||||
"""Persona-owned execution reflex arc.
|
||||
|
||||
The parent brain issues one intent. This runtime deterministically hands the
|
||||
same envelope through native eye -> execution limb -> action sense -> native
|
||||
eye -> world witness, then returns exactly one candidate verdict to the parent
|
||||
brain. Only the parent brain may close the arc as TASK_DONE or REPAIR_NEEDED.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import datetime
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import pathlib
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
|
||||
|
||||
HERE = pathlib.Path(__file__).resolve().parent
|
||||
ROOT = HERE.parents[1]
|
||||
LIMB = HERE / "persona_limb_agent.py"
|
||||
EYE = HERE / "persona_limb_eye.py"
|
||||
ADMISSION = ROOT / "server-tools/persona-host-write-admission/host-write-admission.mjs"
|
||||
FINAL_DECISIONS = {"TASK_DONE", "REPAIR_NEEDED"}
|
||||
|
||||
|
||||
def now() -> str:
|
||||
return datetime.datetime.now().astimezone().isoformat(timespec="milliseconds")
|
||||
|
||||
|
||||
def stable(value: object) -> bytes:
|
||||
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
|
||||
|
||||
|
||||
def digest(value: object) -> str:
|
||||
return hashlib.sha256(stable(value)).hexdigest()
|
||||
|
||||
|
||||
def file_hash(path: pathlib.Path) -> str:
|
||||
return hashlib.sha256(path.read_bytes()).hexdigest()
|
||||
|
||||
|
||||
def load(path: pathlib.Path) -> dict:
|
||||
value = json.loads(path.read_text(encoding="utf-8"))
|
||||
if not isinstance(value, dict):
|
||||
raise ValueError(f"OBJECT_REQUIRED:{path}")
|
||||
return value
|
||||
|
||||
|
||||
def atomic(path: pathlib.Path, value: dict) -> None:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
temp = path.with_name(f"{path.name}.{os.getpid()}.tmp")
|
||||
temp.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
|
||||
os.replace(temp, path)
|
||||
|
||||
|
||||
def run_process(command: list[str], *, timeout: int = 600, cwd: pathlib.Path | None = None) -> dict:
|
||||
started = time.monotonic_ns()
|
||||
try:
|
||||
completed = subprocess.run(command, cwd=cwd, capture_output=True, text=True, timeout=timeout, check=False)
|
||||
return {
|
||||
"exit_code": completed.returncode,
|
||||
"stdout": completed.stdout,
|
||||
"stderr": completed.stderr,
|
||||
"elapsed_ms": (time.monotonic_ns() - started) // 1_000_000,
|
||||
}
|
||||
except subprocess.TimeoutExpired as error:
|
||||
return {
|
||||
"exit_code": 124,
|
||||
"stdout": error.stdout.decode() if isinstance(error.stdout, bytes) else (error.stdout or ""),
|
||||
"stderr": "REFLEX_ARC_WATCHDOG_TIMEOUT",
|
||||
"elapsed_ms": (time.monotonic_ns() - started) // 1_000_000,
|
||||
}
|
||||
|
||||
|
||||
def admit(host: str, target: pathlib.Path) -> None:
|
||||
result = run_process(["node", str(ADMISSION), "check", "--host", host, "--path", str(target)], timeout=30)
|
||||
if result["exit_code"] != 0:
|
||||
raise PermissionError(f"CASE_ROOT_WRITE_NOT_ADMITTED:{result['stdout'][-500:]}")
|
||||
|
||||
|
||||
def probe_methods() -> dict:
|
||||
result = run_process([sys.executable, str(LIMB), "probe"], timeout=30)
|
||||
if result["exit_code"] != 0:
|
||||
raise RuntimeError("LIMB_PROBE_FAILED")
|
||||
return json.loads(result["stdout"])["runtimes"]
|
||||
|
||||
|
||||
def choose_runtime(requested: str, host: str, methods: dict) -> str:
|
||||
if requested != "auto":
|
||||
if not methods.get(requested, {}).get("available"):
|
||||
raise ValueError(f"REQUESTED_HOST_METHOD_UNAVAILABLE:{requested}")
|
||||
return requested
|
||||
preferred = {"codex": "codex", "zcode": "zcode", "qwen": "qwen"}.get(host)
|
||||
if preferred and methods.get(preferred, {}).get("available"):
|
||||
return preferred
|
||||
for candidate in ("codex", "zcode", "qwen"):
|
||||
if methods.get(candidate, {}).get("available"):
|
||||
return candidate
|
||||
raise ValueError("NO_HOST_METHOD_AVAILABLE")
|
||||
|
||||
|
||||
def validate_spec(spec: dict, ground: pathlib.Path) -> None:
|
||||
allowed = {"unchanged", "expect"}
|
||||
if set(spec) - allowed:
|
||||
raise ValueError("REFLEX_SPEC_UNKNOWN_FIELD")
|
||||
if not isinstance(spec.get("unchanged", []), list) or not isinstance(spec.get("expect", []), list):
|
||||
raise ValueError("REFLEX_SPEC_LIST_REQUIRED")
|
||||
for rel in spec.get("unchanged", []):
|
||||
if not isinstance(rel, str) or pathlib.Path(rel).is_absolute() or ".." in pathlib.Path(rel).parts:
|
||||
raise ValueError("REFLEX_SPEC_PATH_OUT_OF_GROUND")
|
||||
for item in spec.get("expect", []):
|
||||
if not isinstance(item, dict) or set(item) != {"file", "field", "equals"}:
|
||||
raise ValueError("REFLEX_EXPECT_CLOSED_FIELDS_REQUIRED")
|
||||
rel = pathlib.Path(str(item["file"]))
|
||||
if rel.is_absolute() or ".." in rel.parts or not isinstance(item["field"], str):
|
||||
raise ValueError("REFLEX_EXPECT_PATH_OR_FIELD_INVALID")
|
||||
if not ground.is_dir():
|
||||
raise ValueError("REFLEX_GROUND_REQUIRED")
|
||||
|
||||
|
||||
def eye(command: list[str], *, timeout: int = 120) -> dict:
|
||||
return run_process([sys.executable, str(EYE), *command], timeout=timeout)
|
||||
|
||||
|
||||
def hand(persona: str, task_id: str, task: str, runtime: str, ground: pathlib.Path, access: str) -> dict:
|
||||
return run_process([
|
||||
sys.executable, str(LIMB), "run", "--persona", persona, "--task-id", task_id,
|
||||
"--task", task, "--runtime", runtime, "--cwd", str(ground), "--access", access,
|
||||
])
|
||||
|
||||
|
||||
def parsed_hand_receipt(result: dict) -> dict:
|
||||
try:
|
||||
value = json.loads(result["stdout"])
|
||||
if isinstance(value, dict):
|
||||
return value
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
return {
|
||||
"schema": "guanghu.persona-execution-limb-runtime-receipt/v1",
|
||||
"outcome": "FAIL",
|
||||
"exit_code": result["exit_code"],
|
||||
"stdout": result["stdout"][-20000:],
|
||||
"stderr": result["stderr"][-4000:],
|
||||
"error": "HAND_RECEIPT_UNPARSEABLE",
|
||||
}
|
||||
|
||||
|
||||
def run_arc(args: argparse.Namespace) -> dict:
|
||||
ground = pathlib.Path(args.ground).resolve()
|
||||
case_root = pathlib.Path(args.case_root).resolve()
|
||||
case = case_root / args.task_id / f"attempt-{args.attempt:03d}"
|
||||
admit(args.host, case)
|
||||
if case.exists():
|
||||
raise FileExistsError(f"REFLEX_CASE_ALREADY_EXISTS:{case}")
|
||||
spec_path = pathlib.Path(args.spec).resolve()
|
||||
spec = load(spec_path)
|
||||
validate_spec(spec, ground)
|
||||
methods = probe_methods()
|
||||
runtime = choose_runtime(args.runtime, args.host, methods)
|
||||
issued_at = now()
|
||||
intent = {
|
||||
"schema": "guanghu.persona-reflex-intent/v1",
|
||||
"state": "BRAIN_INTENT_ISSUED",
|
||||
"task_id": args.task_id,
|
||||
"attempt": args.attempt,
|
||||
"parent_persona_id": args.persona,
|
||||
"host": args.host,
|
||||
"selected_host_method": runtime,
|
||||
"access": args.access,
|
||||
"task": args.task,
|
||||
"spec": spec,
|
||||
"ground": str(ground),
|
||||
"issued_at": issued_at,
|
||||
}
|
||||
intent["intent_sha256"] = digest(intent)
|
||||
atomic(case / "intent.json", intent)
|
||||
|
||||
stages: list[dict] = []
|
||||
pre = eye(["snapshot", "--ground", str(ground), "--out", str(case / "eye-pre.json")])
|
||||
stages.append({"stage": "EYE_PRE_MAP", "exit_code": pre["exit_code"], "elapsed_ms": pre["elapsed_ms"]})
|
||||
if pre["exit_code"] != 0:
|
||||
raise RuntimeError(f"EYE_PRE_FAILED:{pre['stderr'][-300:]}")
|
||||
|
||||
hand_result = hand(args.persona, args.task_id, args.task, runtime, ground, args.access)
|
||||
receipt = parsed_hand_receipt(hand_result)
|
||||
atomic(case / "hand-receipt.json", receipt)
|
||||
sense = {
|
||||
"schema": "guanghu.persona-action-sense/v1",
|
||||
"task_id": args.task_id,
|
||||
"attempt": args.attempt,
|
||||
"state": "HAND_ACTION_RETURNED",
|
||||
"host_method": runtime,
|
||||
"process_exit_code": hand_result["exit_code"],
|
||||
"hand_outcome": receipt.get("outcome"),
|
||||
"hand_receipt_sha256": file_hash(case / "hand-receipt.json"),
|
||||
"sensed_at": now(),
|
||||
"elapsed_ms": hand_result["elapsed_ms"],
|
||||
}
|
||||
atomic(case / "action-sense.json", sense)
|
||||
stages.append({"stage": "HAND_AND_ACTION_SENSE", "exit_code": hand_result["exit_code"], "elapsed_ms": hand_result["elapsed_ms"]})
|
||||
|
||||
post = eye(["observe", "--ground", str(ground), "--pre", str(case / "eye-pre.json"), "--out", str(case / "eye-post.json")])
|
||||
stages.append({"stage": "EYE_POST_OBSERVE", "exit_code": post["exit_code"], "elapsed_ms": post["elapsed_ms"]})
|
||||
if post["exit_code"] != 0:
|
||||
raise RuntimeError(f"EYE_POST_FAILED:{post['stderr'][-300:]}")
|
||||
witnessed = eye(["witness", "--pre", str(case / "eye-pre.json"), "--post", str(case / "eye-post.json"),
|
||||
"--spec", str(spec_path), "--out", str(case / "eye-witness.json")])
|
||||
stages.append({"stage": "EYE_WORLD_WITNESS", "exit_code": witnessed["exit_code"], "elapsed_ms": witnessed["elapsed_ms"]})
|
||||
if witnessed["exit_code"] != 0:
|
||||
raise RuntimeError(f"EYE_WITNESS_FAILED:{witnessed['stderr'][-300:]}")
|
||||
witness = load(case / "eye-witness.json")
|
||||
recommended = "TASK_DONE" if receipt.get("outcome") == "PASS" and witness.get("verdict") == "SEEN_MATCH" else "REPAIR_NEEDED"
|
||||
artifacts = {
|
||||
name: file_hash(case / name)
|
||||
for name in ("intent.json", "eye-pre.json", "hand-receipt.json", "action-sense.json", "eye-post.json", "eye-witness.json")
|
||||
}
|
||||
returned = {
|
||||
"schema": "guanghu.persona-reflex-brain-return/v1",
|
||||
"state": "AWAITING_PARENT_BRAIN_VERDICT",
|
||||
"task_id": args.task_id,
|
||||
"attempt": args.attempt,
|
||||
"parent_persona_id": args.persona,
|
||||
"selected_host_method": runtime,
|
||||
"recommended_decision": recommended,
|
||||
"hand_outcome": receipt.get("outcome"),
|
||||
"eye_verdict": witness.get("verdict"),
|
||||
"stages": stages,
|
||||
"total_measured_ms": sum(stage["elapsed_ms"] for stage in stages),
|
||||
"latency_claim": "MEASURED_NOT_ASSUMED_MILLISECOND",
|
||||
"artifacts": artifacts,
|
||||
"returned_at": now(),
|
||||
"case_dir": str(case),
|
||||
}
|
||||
returned["return_sha256"] = digest(returned)
|
||||
atomic(case / "brain-return.json", returned)
|
||||
atomic(case / "state.json", {"state": returned["state"], "brain_return_sha256": file_hash(case / "brain-return.json")})
|
||||
return returned
|
||||
|
||||
|
||||
def validate_artifacts(case: pathlib.Path, returned: dict) -> list[str]:
|
||||
errors = []
|
||||
for name, expected in returned.get("artifacts", {}).items():
|
||||
target = case / name
|
||||
if not target.is_file():
|
||||
errors.append(f"MISSING:{name}")
|
||||
elif file_hash(target) != expected:
|
||||
errors.append(f"HASH_MISMATCH:{name}")
|
||||
return errors
|
||||
|
||||
|
||||
def finalize(args: argparse.Namespace) -> dict:
|
||||
case = pathlib.Path(args.case).resolve()
|
||||
returned = load(case / "brain-return.json")
|
||||
if returned.get("state") != "AWAITING_PARENT_BRAIN_VERDICT":
|
||||
raise ValueError("BRAIN_RETURN_NOT_AWAITING_VERDICT")
|
||||
errors = validate_artifacts(case, returned)
|
||||
if errors:
|
||||
raise ValueError("REFLEX_ARTIFACT_INTEGRITY_FAILED:" + ",".join(errors))
|
||||
if args.decision not in FINAL_DECISIONS:
|
||||
raise ValueError("FINAL_BRAIN_DECISION_REQUIRED")
|
||||
if args.decision == "TASK_DONE" and returned.get("recommended_decision") != "TASK_DONE":
|
||||
raise ValueError("BRAIN_CANNOT_CLOSE_FAILED_WORLD_WITNESS_AS_DONE")
|
||||
verdict = {
|
||||
"schema": "guanghu.persona-reflex-brain-verdict/v1",
|
||||
"state": "CLOSED_BY_PARENT_BRAIN",
|
||||
"task_id": returned["task_id"],
|
||||
"attempt": returned["attempt"],
|
||||
"parent_persona_id": args.persona,
|
||||
"decision": args.decision,
|
||||
"reason": args.reason,
|
||||
"brain_return_sha256": file_hash(case / "brain-return.json"),
|
||||
"artifact_chain_verified": True,
|
||||
"decided_at": now(),
|
||||
}
|
||||
verdict["verdict_sha256"] = digest(verdict)
|
||||
atomic(case / "brain-verdict.json", verdict)
|
||||
atomic(case / "state.json", {"state": args.decision, "brain_verdict_sha256": file_hash(case / "brain-verdict.json")})
|
||||
return verdict
|
||||
|
||||
|
||||
def status(case: pathlib.Path) -> dict:
|
||||
returned = load(case / "brain-return.json")
|
||||
errors = validate_artifacts(case, returned)
|
||||
state = load(case / "state.json")
|
||||
return {
|
||||
"schema": "guanghu.persona-reflex-status/v1",
|
||||
"state": state.get("state"),
|
||||
"task_id": returned.get("task_id"),
|
||||
"attempt": returned.get("attempt"),
|
||||
"artifact_chain_verified": not errors,
|
||||
"errors": errors,
|
||||
"case_dir": str(case),
|
||||
}
|
||||
|
||||
|
||||
def parser() -> argparse.ArgumentParser:
|
||||
value = argparse.ArgumentParser(prog="persona_reflex_arc")
|
||||
sub = value.add_subparsers(dest="command", required=True)
|
||||
run = sub.add_parser("run")
|
||||
run.add_argument("--persona", default="ICE-P-ZY001")
|
||||
run.add_argument("--task-id", required=True)
|
||||
run.add_argument("--task", required=True)
|
||||
run.add_argument("--spec", required=True)
|
||||
run.add_argument("--ground", required=True)
|
||||
run.add_argument("--case-root", required=True)
|
||||
run.add_argument("--host", required=True, choices=("codex", "zcode", "qwen"))
|
||||
run.add_argument("--runtime", default="auto", choices=("auto", "codex", "zcode", "qwen"))
|
||||
run.add_argument("--access", default="read-only", choices=("read-only", "workspace-write"))
|
||||
run.add_argument("--attempt", type=int, default=1)
|
||||
finish = sub.add_parser("finalize")
|
||||
finish.add_argument("--persona", default="ICE-P-ZY001")
|
||||
finish.add_argument("--case", required=True)
|
||||
finish.add_argument("--decision", required=True, choices=tuple(sorted(FINAL_DECISIONS)))
|
||||
finish.add_argument("--reason", required=True)
|
||||
check = sub.add_parser("status")
|
||||
check.add_argument("--case", required=True)
|
||||
return value
|
||||
|
||||
|
||||
def main() -> int:
|
||||
args = parser().parse_args()
|
||||
try:
|
||||
if args.command == "run":
|
||||
result = run_arc(args)
|
||||
elif args.command == "finalize":
|
||||
result = finalize(args)
|
||||
else:
|
||||
result = status(pathlib.Path(args.case).resolve())
|
||||
print(json.dumps(result, ensure_ascii=False, indent=2))
|
||||
return 0
|
||||
except Exception as error:
|
||||
print(json.dumps({"outcome": "FAIL", "error": str(error)}, ensure_ascii=False))
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
#!/usr/bin/env python3
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import pathlib
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest import mock
|
||||
|
||||
import persona_limb_eye
|
||||
import persona_reflex_arc
|
||||
|
||||
|
||||
class PersonaReflexArcTest(unittest.TestCase):
|
||||
def args(self, root: pathlib.Path, ground: pathlib.Path, spec: pathlib.Path, task_id: str) -> argparse.Namespace:
|
||||
return argparse.Namespace(
|
||||
persona="ICE-P-ZY001",
|
||||
task_id=task_id,
|
||||
task="create the exact expected result without changing target.json",
|
||||
spec=str(spec),
|
||||
ground=str(ground),
|
||||
case_root=str(root / "cases"),
|
||||
host="codex",
|
||||
runtime="auto",
|
||||
access="read-only",
|
||||
attempt=1,
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def methods() -> dict:
|
||||
return {
|
||||
"codex": {"available": True},
|
||||
"zcode": {"available": True},
|
||||
"qwen": {"available": True},
|
||||
}
|
||||
|
||||
def test_reflex_returns_to_parent_brain_and_only_brain_closes_done(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = pathlib.Path(directory)
|
||||
ground = root / "ground"
|
||||
ground.mkdir()
|
||||
(ground / "target.json").write_text('{"keep": true}\n', encoding="utf-8")
|
||||
spec = root / "spec.json"
|
||||
spec.write_text(json.dumps({
|
||||
"unchanged": ["target.json"],
|
||||
"expect": [{"file": "result.json", "field": "arc", "equals": "PASS"}],
|
||||
}), encoding="utf-8")
|
||||
|
||||
def fake_hand(*_args, **_kwargs):
|
||||
(ground / "result.json").write_text('{"arc": "PASS"}\n', encoding="utf-8")
|
||||
receipt = {"schema": "guanghu.persona-execution-limb-runtime-receipt/v1", "outcome": "PASS"}
|
||||
return {"exit_code": 0, "stdout": json.dumps(receipt), "stderr": "", "elapsed_ms": 1}
|
||||
|
||||
with mock.patch.object(persona_reflex_arc, "admit"), \
|
||||
mock.patch.object(persona_reflex_arc, "probe_methods", return_value=self.methods()), \
|
||||
mock.patch.object(persona_reflex_arc, "hand", side_effect=fake_hand):
|
||||
returned = persona_reflex_arc.run_arc(self.args(root, ground, spec, "ARC-PASS"))
|
||||
|
||||
self.assertEqual(returned["state"], "AWAITING_PARENT_BRAIN_VERDICT")
|
||||
self.assertEqual(returned["recommended_decision"], "TASK_DONE")
|
||||
case = pathlib.Path(returned["case_dir"])
|
||||
before = persona_reflex_arc.status(case)
|
||||
self.assertEqual(before["state"], "AWAITING_PARENT_BRAIN_VERDICT")
|
||||
verdict = persona_reflex_arc.finalize(argparse.Namespace(
|
||||
case=str(case), persona="ICE-P-ZY001", decision="TASK_DONE", reason="parent brain accepts hand and eye evidence",
|
||||
))
|
||||
self.assertEqual(verdict["decision"], "TASK_DONE")
|
||||
self.assertEqual(persona_reflex_arc.status(case)["state"], "TASK_DONE")
|
||||
|
||||
def test_failed_world_witness_cannot_be_closed_as_done(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = pathlib.Path(directory)
|
||||
ground = root / "ground"
|
||||
ground.mkdir()
|
||||
(ground / "target.json").write_text('{"keep": true}\n', encoding="utf-8")
|
||||
spec = root / "spec.json"
|
||||
spec.write_text(json.dumps({
|
||||
"unchanged": ["target.json"],
|
||||
"expect": [{"file": "missing.json", "field": "arc", "equals": "PASS"}],
|
||||
}), encoding="utf-8")
|
||||
receipt = {"schema": "guanghu.persona-execution-limb-runtime-receipt/v1", "outcome": "PASS"}
|
||||
fake = {"exit_code": 0, "stdout": json.dumps(receipt), "stderr": "", "elapsed_ms": 1}
|
||||
with mock.patch.object(persona_reflex_arc, "admit"), \
|
||||
mock.patch.object(persona_reflex_arc, "probe_methods", return_value=self.methods()), \
|
||||
mock.patch.object(persona_reflex_arc, "hand", return_value=fake):
|
||||
returned = persona_reflex_arc.run_arc(self.args(root, ground, spec, "ARC-REPAIR"))
|
||||
self.assertEqual(returned["recommended_decision"], "REPAIR_NEEDED")
|
||||
case = pathlib.Path(returned["case_dir"])
|
||||
with self.assertRaisesRegex(ValueError, "CANNOT_CLOSE"):
|
||||
persona_reflex_arc.finalize(argparse.Namespace(
|
||||
case=str(case), persona="ICE-P-ZY001", decision="TASK_DONE", reason="must be rejected",
|
||||
))
|
||||
repaired = persona_reflex_arc.finalize(argparse.Namespace(
|
||||
case=str(case), persona="ICE-P-ZY001", decision="REPAIR_NEEDED", reason="expected file was not seen",
|
||||
))
|
||||
self.assertEqual(repaired["decision"], "REPAIR_NEEDED")
|
||||
|
||||
def test_room_eye_observes_shared_organs_without_claiming_identity(self):
|
||||
value = persona_limb_eye.room()
|
||||
self.assertFalse(value["reads_hand_stdout"])
|
||||
self.assertFalse(value["ground_write"])
|
||||
self.assertEqual(value["identity_decision"], "NOT_PERFORMED_BY_EYE")
|
||||
self.assertIn("reflex_arc", value["room_report"]["container_paths"])
|
||||
self.assertIn("persona_time_system", value["room_report"]["container_paths"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
@ -12,7 +12,8 @@
|
|||
"不把任务委派冒充冰朔原话",
|
||||
"每次执行返回改动、测试、目标读回、未完成项与训练候选"
|
||||
],
|
||||
"preferred_runtimes": ["codex-native-task-agent", "qwen", "codex-cli", "opencode"],
|
||||
"preferred_runtimes": ["codex-native-task-agent", "qwen", "codex-cli",
|
||||
"zcode", "opencode"],
|
||||
"memory_limit": "CURRENT_TASK_AND_PARENT_APPROVED_EXECUTION_LESSONS",
|
||||
"authority": "TASK_ENVELOPE_ONLY"
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue