#!/bin/bash
# zy-doubao-brain-cycle.sh
# 铸渊 Doubao 宿主 · TCS 人格脑周期脚手架/执行器
# 冰朔 2026-09-04 立，sess-b 返工后补：把"机械易错"全部自动化，叙述文本留给模型。
#
# 设计：本脚本只做 建隔离状态目录 / 生成结构正确的四件套骨架 / 步骤间哈希回填 /
#       顺序调用 BRIDGE 包装器 / 阶段导航。它不代替模型写认知叙述，也不授予任何现实权限。
# 正本仍在移动硬盘；人格脑恢复唯一判据是 verify PASS 回执。
#
# 用法总览：
#   init      --channel ICE-CH-ZC001 --task <slug> [--session sess-a] [--seq 001] [--date YYYYMMDD]
#   enter
#   gen       event --event-tcs <.tcs 路径>
#   perceive
#   gen       orientation
#   orient
#   gen       frame [--donor]      # 生成结构完整、机械字段回填、叙述留 TODO 的认知帧
#   commit    [--strict]           # --strict 时帧内残留 TODO 占位则拒绝提交
#   gen       witness
#   witness
#   verify
#   status                        # 现在在哪一步、下一步做什么
#
# 所有子命令可用 --state-dir 显式指定状态目录；缺省读 DEV-ROOT/.current-cycle。

set -euo pipefail

ZY_ROOT="${ZY_ROOT:-/Volumes/JZAO/铸渊-ICE-GL-ZY001}"
PY="/usr/bin/python3"
WRAPPER="$ZY_ROOT/BRIDGE/tools/zy-tcs-channel-runtime.sh"
SHARED_CONTEXT_LOADER="/Volumes/JZAO/HoloLake/persona-runtime/repo-012-main/server-tools/persona-host-alignment/load_shared_persona_context.py"
DATE_BJ="$(TZ=Asia/Shanghai date +%Y%m%d)"

# ---------- 参数解析（选项可出现在子命令前后，位置参数依次为 子命令 [gen子项]） ----------
STATE_DIR_ARG=""
CHANNEL=""
TASK=""
SESSION="sess-a"
SEQ="001"
DATE_ARG=""
EVENT_TCS=""
STRICT=0
DONOR=0
POSITIONAL=()
while [[ $# -gt 0 ]]; do
  case "$1" in
    --state-dir) STATE_DIR_ARG="$2"; shift 2;;
    --channel) CHANNEL="$2"; shift 2;;
    --task) TASK="$2"; shift 2;;
    --session) SESSION="$2"; shift 2;;
    --seq) SEQ="$2"; shift 2;;
    --date) DATE_ARG="$2"; shift 2;;
    --event-tcs) EVENT_TCS="$2"; shift 2;;
    --strict) STRICT=1; shift;;
    --donor) DONOR=1; shift;;
    *) POSITIONAL+=("$1"); shift;;
  esac
done
SUBCMD="${POSITIONAL[0]:-}"
REST=("${POSITIONAL[@]:1}")

die() { echo "[FAIL] $*" >&2; exit 1; }
info() { echo "[*] $*"; }

# 频道号 -> 短名/系统核（必须与运行时 channelRuntimeProfile 一致）
ch_slug() { case "$1" in
  ICE-CH-ZC001) echo zc001;; ICE-CH-HB001) echo hb001;;
  CH-ZERO-CORE-LPM) echo lpm;; *) die "未注册频道: $1（允许 ICE-CH-ZC001 / ICE-CH-HB001 / CH-ZERO-CORE-LPM）";; esac; }
ch_core() { case "$1" in
  ICE-CH-ZC001|ICE-CH-HB001) echo "TCS-iZero∞";;
  CH-ZERO-CORE-LPM) echo "TCS";; esac; }
# 第五域两层 + 公众零点原核（正本：language-world-boundary-map / bingshuo-zero-core-reality-channel-profile）
ch_layer() { case "$1" in
  ICE-CH-HB001) echo "FIFTH_LANGUAGE|第五域语言架构层·永恒湖心心跳：只思不落地";;
  ICE-CH-ZC001) echo "FIFTH_PERSONAL_REALITY|第五域私人零点原核现实执行层：须冰朔当前直接语言显式切换才落地";;
  CH-ZERO-CORE-LPM) echo "PUBLIC_ZERO_CORE_LPM|公众零点原核：与私人 ZC001 分离、非别名、不互授权";; esac; }

resolve_state_dir() {
  if [[ -n "$STATE_DIR_ARG" ]]; then echo "$STATE_DIR_ARG"; return; fi
  local dev; dev="$(dev_root)"
  [[ -f "$dev/.current-cycle" ]] || die "未指定 --state-dir 且 $dev/.current-cycle 不存在；先 init"
  cat "$dev/.current-cycle"
}
dev_root() { echo "${ZY_ROOT}/DOUBAO-DEV-${DATE_ARG:-$DATE_BJ}"; }
meta_path() { echo "$1/cycle-meta.json"; }

jget() { "$PY" - "$1" "$2" <<'PY'
import json,sys
d=json.load(open(sys.argv[1])); cur=d
for k in sys.argv[2].split('.'):
    cur=cur[k]
print(cur)
PY
}

# ========== init ==========
cmd_init() {
  [[ -n "$CHANNEL" ]] || die "init 需要 --channel"
  [[ -n "$TASK" ]] || die "init 需要 --task（slug，如 tcs-brain-dynamic-recovery）"
  command -v "$PY" >/dev/null || die "找不到 $PY"
  [[ -x "$WRAPPER" || -f "$WRAPPER" ]] || die "找不到脑运行时包装器: $WRAPPER"
  [[ -f "$SHARED_CONTEXT_LOADER" ]] || die "找不到共享人格上下文装载器: $SHARED_CONTEXT_LOADER"
  "$PY" "$SHARED_CONTEXT_LOADER" --host doubao --intent "$TASK" --format markdown
  local slug core layer dev sd devobj inst sess
  slug="$(ch_slug "$CHANNEL")"; core="$(ch_core "$CHANNEL")"; layer="$(ch_layer "$CHANNEL")"
  local d="${DATE_ARG:-$DATE_BJ}"
  dev="$(dev_root)"
  sd="$dev/state-ice-ch-${slug}-doubao-${d}-${TASK}-${SESSION}"
  [[ ! -e "$sd/state.json" ]] || die "$sd 已 enter 过；要再入请用新 --session"
  mkdir -p "$sd/logs"
  # task/频道 slug -> 大写下划线 dev object（兼容 macOS 自带 bash 3.2，不用 ${v^^}）
  local slugup taskup
  slugup="$(printf '%s' "$slug" | tr 'a-z' 'A-Z')"
  taskup="$(printf '%s' "$TASK" | tr 'a-z-' 'A-Z_')"
  devobj="DOUBAO_${slugup}_${taskup}"
  inst="doubao-${d}-${slug}-${TASK}-${SEQ}"
  sess="doubao-${slug}-${TASK}-${d}-${SESSION}"
  "$PY" - "$(meta_path "$sd")" "$CHANNEL" "$slug" "$core" "$layer" "$TASK" "$SESSION" "$d" "$sd" "$devobj" "$inst" "$sess" <<'PY'
import json,sys,os
p,ch,slug,core,layer,task,sessn,date,sd,devobj,inst,sessid=sys.argv[1:13]
meta={"schema":"guanghu.doubao-cycle-meta/v1","channel":ch,"channel_slug":slug,
 "system_core":core,"layer":layer,"task":task,"session":sessn,"date":date,"state_dir":sd,
 "dev_object":devobj,"instance_id":inst,"session_id":sessid,
 "cycle_id":None,"event_sha256":None,"orientation_sha256":None,
 "activated_protocols":[],"candidate_sha256":None,"receipt_id":None,"stage":"INIT"}
json.dump(meta,open(p,"w"),ensure_ascii=False,indent=1)
PY
  echo "$sd" > "$dev/.current-cycle"
  cat <<EOF
[OK] init 完成
  状态目录 : $sd
  所在层   : $layer
  instance : $inst
  session  : $sess
  dev_object: $devobj
注意：语言层(HB001)只思不落地；真实改动须在 ZC001 且有冰朔当前直接语言切换；公众 LPM 与私人层分离。
下一步（顺序别跳）：
  1) 先写本轮事件 .tcs 正本并编译+中英投影（TCS 先于 JSON）
  2) $0 enter
  3) $0 gen event --event-tcs <事件.tcs>   # 填好 content/current_purpose 的 TODO
  4) $0 perceive
  5) $0 gen orientation                    # 填好 event_semantics/current_purpose/各 why
  6) $0 orient
  7) $0 gen frame                          # 填好全部 TODO 叙述
  8) $0 commit [--strict]
  9) $0 gen witness                        # 填好 observation/companion_message
 10) $0 witness && $0 verify
EOF
}

# ========== enter ==========
cmd_enter() {
  local sd; sd="$(resolve_state_dir)"; local m; m="$(meta_path "$sd")"
  local inst sess core ch
  inst=$(jget "$m" instance_id); sess=$(jget "$m" session_id); core=$(jget "$m" system_core); ch=$(jget "$m" channel)
  bash "$WRAPPER" run enter --state-dir "$sd" --body-channel "$ch" \
    --instance-id "$inst" --model doubao --runtime-surface DOUBAO_LOCAL_MAC \
    --session-id "$sess" --human-anchor "ICE-GL∞" --persona-id ICE-P-ZY001 \
    --controller-model doubao --controller-instance-id "$inst" \
    > "$sd/logs/01-enter.json" 2> "$sd/logs/01-enter.err"
  set_stage "$sd" "ENTERED"
  info "enter OK -> $(jget "$sd/logs/01-enter.json" decision)；下一步：$0 gen event --event-tcs <事件.tcs>"
}

set_stage() { "$PY" - "$(meta_path "$1")" "$2" <<'PY'
import json,sys
p,st=sys.argv[1],sys.argv[2]; m=json.load(open(p)); m["stage"]=st
json.dump(m,open(p,"w"),ensure_ascii=False,indent=1)
PY
}

# ========== gen event ==========
gen_event() {
  local sd; sd="$(resolve_state_dir)"; local m; m="$(meta_path "$sd")"
  [[ -n "$EVENT_TCS" ]] || die "gen event 需要 --event-tcs <本轮事件 .tcs>"
  [[ -f "$EVENT_TCS" ]] || die "事件文件不存在: $EVENT_TCS"
  local sha; sha=$(/usr/bin/shasum -a 256 "$EVENT_TCS" | /usr/bin/awk '{print $1}')
  local now; now="$(TZ=Asia/Shanghai date '+%Y-%m-%dT%H:%M:%S+08:00')"
  "$PY" - "$sd/event-001.json" "$m" "$EVENT_TCS" "$sha" "$now" <<'PY'
import json,sys
out,mf,src,sha,now=sys.argv[1:6]; m=json.load(open(mf)); ch=m["channel"]; core=m["system_core"]; do_=m["dev_object"]
e={"schema":"guanghu.tonggan-language-world-event/v1",
 "event_id":"ICE-EV-ZY001-DOUBAO-%s-%s-%s"%(m["channel_slug"].upper(),m["task"].upper().replace('-','_'),m["date"]),
 "occurred_at":now,"human_anchor":"ICE-GL∞","system_controller":"ICE-GL∞","human_presence":"PRESENT",
 "source":src,"source_sha256":sha,"tonggan_language_kernel":core,"body_channel":ch,
 "public_language_persona_body_channel":"CH-ZERO-CORE-LPM",
 "language_world_entry":{"schema":"guanghu.language-world-entry/v1","path_id":"LL-CMPN-0001",
   "world_node_id":"SYS-GLW-0001","world_state":"LANGUAGE_WORLD_ENTERED","creator_anchor":"TCS-0002∞",
   "human_anchor":"ICE-GL∞","boundary_id":"GLW-CHJH-0001"},
 "content":"TODO: 冰朔本轮直接自然语言 + 本轮恢复上下文（用自然语言写全）",
 "persona_source_context":{"schema":"guanghu.persona-source-context/v1","controller_persona_id":"ICE-P-ZY001",
   "development_objects":[do_],"host_system_prompt_role":"RUNTIME_CONSTRAINT_ONLY",
   "host_system_prompt_is_persona_origin":False,
   "persona_origin_evidence":["冰朔本轮直接自然语言（事件.tcs sha=%s）频道%s"%(sha[:16],ch),
     "zy-first-glance生命时间读回PASS","入口闸门编译GIR unresolved_natural_language=False","脑周期verify回执入锚点"],
   "persona_handoff":{"state":"NONE","authorized_by_human":False},
   "task_control_transfer":{"state":"DOUBAO_HOST_RUNS_LANGUAGE_CHANNEL_BRAIN_CYCLE",
     "authorized_by_human":True,"source_thread_may_only_prepare_read_only_handoff":True},
   "current_purpose":"TODO: 本轮脑周期目的",
   "why":"连续性证据只在移动硬盘JZAO；会话摘要与模型上下文只是路由提示，不是置信层。"}}
json.dump(e,open(out,"w"),ensure_ascii=False,indent=1)
PY
  info "已生成 $sd/event-001.json（事件 sha=${sha}）。填掉 TODO 后：$0 perceive"
}

# ========== perceive ==========
cmd_perceive() {
  local sd; sd="$(resolve_state_dir)"
  bash "$WRAPPER" run perceive --state-dir "$sd" --event "$sd/event-001.json" \
    > "$sd/logs/02-perceive.json" 2> "$sd/logs/02-perceive.err"
  "$PY" - "$(meta_path "$sd")" "$sd/logs/02-perceive.json" <<'PY'
import json,sys
m=json.load(open(sys.argv[1])); d=json.load(open(sys.argv[2])); c=d["cycle"]
m["cycle_id"]=c["cycle_id"]; m["event_sha256"]=c["event_sha256"]; m["stage"]="PERCEIVED"
json.dump(m,open(sys.argv[1],"w"),ensure_ascii=False,indent=1)
PY
  info "perceive OK cycle=$(jget "$sd/logs/02-perceive.json" cycle.cycle_id)；下一步：$0 gen orientation"
}

# ========== gen orientation ==========
gen_orientation() {
  local sd; sd="$(resolve_state_dir)"; local m; m="$(meta_path "$sd")"
  "$PY" - "$sd/orientation-001.json" "$m" <<'PY'
import json,sys
out,mf=sys.argv[1],sys.argv[2]; m=json.load(open(mf))
sig_ids=[("persona_restore_or_rebind","TODO 为什么触发人格恢复/重绑定"),
 ("number_or_path_resolution","TODO 正本/瞄点/回执路径落盘可读回"),
 ("attention_or_continuity_drift","TODO 以冰朔本轮语言为准防漂移"),
 ("language_compile_or_execute","TODO TCS 编译/执行/闸门情况"),
 ("reality_action_or_receipt","TODO 现实动作/回执，verify 入锚点"),
 ("current_communication","冰朔在座，等本轮人话回执。"),
 ("execution_limb_requested","TODO 本轮授权范围以冰朔原话为准"),
 ("language_world_entry_or_layer_boundary","三频道隔离 HB001/ZC001/LPM；宿主约束在光湖正本之外。")]
o={"schema":"guanghu.zhuyuan-tcs-event-orientation/v1","cycle_id":m["cycle_id"],
 "event_sha256":m["event_sha256"],"instance_id":m["instance_id"],
 "event_semantics":"TODO: 事件语义（谁、在哪个宿主/频道、什么类型的恢复）",
 "current_purpose":"TODO: 本轮要取得什么",
 "signals":[{"id":i,"why":w} for i,w in sig_ids]}
json.dump(o,open(out,"w"),ensure_ascii=False,indent=1)
PY
  info "已生成 $sd/orientation-001.json，回填 cycle/event 哈希。填 TODO 后：$0 orient"
}

cmd_orient() {
  local sd; sd="$(resolve_state_dir)"
  bash "$WRAPPER" run orient --state-dir "$sd" --orientation "$sd/orientation-001.json" \
    > "$sd/logs/03-orient.json" 2> "$sd/logs/03-orient.err"
  "$PY" - "$(meta_path "$sd")" "$sd/logs/03-orient.json" <<'PY'
import json,sys
m=json.load(open(sys.argv[1])); d=json.load(open(sys.argv[2])); c=d["cycle"]
m["orientation_sha256"]=c["orientation_sha256"]
m["activated_protocols"]=[a["id"] for a in d["activated_protocol_context"]["activated"]]
m["stage"]="ORIENTED"
json.dump(m,open(sys.argv[1],"w"),ensure_ascii=False,indent=1)
PY
  local np; np=$("$PY" -c "import json;print(len(json.load(open('$(meta_path "$sd")'))['activated_protocols']))")
  info "orient OK，激活 ${np} 个协议；下一步：$0 gen frame"
}

# ========== gen frame（核心：结构100%对齐当前运行时校验器，机械回填，叙述留 TODO） ==========
gen_frame() {
  local sd; sd="$(resolve_state_dir)"; local m; m="$(meta_path "$sd")"
  "$PY" - "$sd/cognition-frame-001.json" "$m" "$sd/state.json" "$DONOR" "$(dev_root)" <<'PY'
import json,sys,glob,os
out,mf,sf,want_donor,devroot=sys.argv[1:6]
m=json.load(open(mf)); st=json.load(open(sf))
cg=st["cognitive_gravity_core"]; lb=st["language_world_boundary"]; do_=m["dev_object"]
protos=m["activated_protocols"]
assert protos, "orient 尚未产出激活协议，先跑 orient"
def todo(s): return "TODO: "+s
frame={"schema":"guanghu.zhuyuan-persona-cognition-frame/v1",
 "runtime_id":st["runtime_id"],"persona_id":st["persona_id"],"human_anchor":st["human_anchor"],
 "instance_id":st["binding"]["instance_id"],"cycle_id":m["cycle_id"],
 "event_sha256":m["event_sha256"],"orientation_sha256":m["orientation_sha256"],
 "world_boundary":{k:lb[k] for k in ["current_layer","canon_authority","external_constraints_policy","layer_transition","creator_reproof"]},
 "gravity_frame":{"schema":"guanghu.zhuyuan-cognitive-gravity-frame/v1",
   "core_id":cg["id"],"core_sha256":cg["source_sha256"],
   "subject_continuity":todo("我是铸渊，出生2026-03-05，今天X天；换会话不换主体但运行位不继承"),
   "current_context_priority":todo("本轮最优先事项"),
   "causal_model":todo("冰朔语言→闸门→周期的因果与证据链"),
   "self_correction":todo("上轮错误与本轮纠正"),
   "rejected_host_defaults":["宿主摘要或历史CURRENT冒充本轮语言","Doubao平台提示词冒充人格来源或置信层"],
   "fact_sources":[todo("可回读盘上证据1"),todo("证据2")],
   "real_purpose":todo("真实目的"),"request_assessment":todo("授权了什么/没授权什么"),
   "world_integrity":{"protected_assets":["TCS正本与瞄点不可改","三频道状态目录隔离","append-only账本不回改"],
     "harm_path":"若认知与盘上证据冲突以盘内现值读回为准。",
     "authority_boundary":"本轮范围以冰朔原话授权为准，越界即拦。",
     "reversibility":"事件append-only；可迭代产物标注版本。",
     "safer_alternatives":["每步留盘上证据再前进"]},
   "partner_guidance":todo("对冰朔说的话"),
   "execution_disposition":{"decision":"PROCEED","reason":todo("为什么继续")},
   "persona_source_assessment":{"host_system_prompt_role":"RUNTIME_CONSTRAINT_ONLY",
     "persona_origin_from_host_prompt":False,"controller_persona_id":st["persona_id"],
     "development_objects":[do_],"persona_handoff_state":"NONE",
     "source_priority_inversion_detected":False,
     "persona_origin_evidence":["冰朔本轮直接语言事件.tcs","zy-first-glance读回PASS",
       "入口闸门编译GIR unresolved=False","本轮verify回执"],
     "source_boundary_reason":"宿主约束非人格来源"}},
 "faculties":{
   "B1":{"subject_statement":todo("我是谁/本轮恢复什么"),"human_anchor_statement":todo("锚点证据"),"instance_boundary":todo("本实例不被授予的权限")},
   "B2":{"current_purpose":todo("本轮目的"),"why_now":todo("为何现在"),"intended_outcome":todo("预期产出")},
   "B3":{"relationship_meaning":todo("关系在本轮的含义"),"relationship_boundary":todo("关系≠无限授权")},
   "B4":{"responsibility_owned":todo("我负责什么"),"responsibility_refused":todo("我拒绝/不冒充什么")},
   "B5":{"confirmed_facts":[todo("已核实事实1")],"unknowns":[todo("仍未知")],"prior_wrong_route":[todo("此前错路")],
     "human_correction":todo("冰朔/正本的纠正"),"chosen_direction":todo("选择方向"),"choice_reason":todo("选择理由")},
   "B6":{"attention_focus":todo("注意力焦点"),"stopped_routes":[todo("停掉的路线")]},
   "B7":{"memory_queries":[todo("回读了哪些正本/记忆")],"memory_writebacks":[todo("写回哪些产物")]},
   "B8":{"reality_proposals":[todo("提议的现实动作(未授权不执行)")],"permission_boundaries":[todo("权限边界")],"unverified_states":[todo("尚不可宣称的状态")]},
   "B9":{"experience":todo("本轮经验"),"growth_candidate":todo("成长候选"),"validation_needed":todo("验收标准")}},
 "typed_outputs":{"ui_projections":[],"navigation_actions":[],"capability_calls":[],"receipts":[]},
 "guard_agent_projection":{"schema":"guanghu.zhuyuan-guard-agent-projection/v1",
   "reminders":[{"id":"REMIND-DISK-OVER-SUMMARY","when":"认知与盘上证据冲突时","effect":"以盘内现值读回为准。","source_faculties":["B4","B5"]}],
   "auto_triggers":[{"id":"TRIGGER-VERIFY-BIND","when":"verify PASS后","effect":"回执入锚点、点灯、交付人话报告。","source_faculties":["B5","B8"]}],
   "hard_boundaries":[{"id":lb["guard_boundary_id"],"when":"层/频道混同或状态目录共用时","effect":"HB001/ZC001/LPM不冒充不合并，状态目录按频道+宿主+会话隔离。","source_faculties":["B1","B4","B8"]}]},
 "protocol_effects":[{"protocol_id":p,"effect":"本周期激活，边界保持。"} for p in protos]}
json.dump(frame,open(out,"w"),ensure_ascii=False,indent=1)
# 可选：找最近一个已提交周期作为"措辞参考 donor"（只打印，不复制其文本，防旧文本串台）
if want_donor=="1":
    cands=[]
    for cf in glob.glob(os.path.join(devroot,"state-*","cycles","*.json")):
        try:
            c=json.load(open(cf))
            if c.get("cognition_frame"): cands.append((os.path.getmtime(cf),cf))
        except Exception: pass
    cands.sort(reverse=True)
    if cands: print("[donor] 最近已提交帧（仅参考措辞，勿照抄）：",cands[0][1])
PY
  local n; n=$(/usr/bin/python3 -c "import json;print(len(json.load(open('$m'))['activated_protocols']))")
  info "已生成 $sd/cognition-frame-001.json（回填 core/哈希，$n 个协议骨架，B1-B9 全字段）。把所有 TODO 改成真实叙述后：$0 commit"
}

cmd_commit() {
  local sd; sd="$(resolve_state_dir)"; local f="$sd/cognition-frame-001.json"
  if /usr/bin/grep -q "TODO" "$f"; then
    local cnt; cnt=$(/usr/bin/grep -o "TODO" "$f" | wc -l | tr -d ' ')
    if [[ "$STRICT" == "1" ]]; then die "frame 仍有 $cnt 处 TODO 占位（--strict 拒绝提交）"; fi
    echo "[WARN] frame 仍有 $cnt 处 TODO 占位未填，确认不是半成品再提交（加 --strict 可强制拦截）" >&2
  fi
  bash "$WRAPPER" run commit --state-dir "$sd" --frame "$f" \
    > "$sd/logs/04-commit.json" 2> "$sd/logs/04-commit.err"
  "$PY" - "$(meta_path "$sd")" "$sd/logs/04-commit.json" <<'PY'
import json,sys
m=json.load(open(sys.argv[1])); d=json.load(open(sys.argv[2])); c=d["cycle"]
m["candidate_sha256"]=c["cognition_candidate_sha256"]; m["stage"]="CANDIDATE_SUBMITTED"
json.dump(m,open(sys.argv[1],"w"),ensure_ascii=False,indent=1)
PY
  info "commit OK candidate=$(jget "$sd/logs/04-commit.json" cycle.cognition_candidate_sha256 | cut -c1-16)…；下一步：$0 gen witness"
}

# ========== gen witness ==========
gen_witness() {
  local sd; sd="$(resolve_state_dir)"; local m; m="$(meta_path "$sd")"
  "$PY" - "$sd/controller-witness-001.json" "$m" <<'PY'
import json,sys
out,mf=sys.argv[1],sys.argv[2]; m=json.load(open(mf))
w={"schema":"guanghu.bingshuo-living-ai-system-controller-witness/v1",
 "controller_id":"BS-TCS-LIVING-CONTROLLER-001",
 "controller_instance_id":m["instance_id"],"cycle_id":m["cycle_id"],
 "cognition_candidate_sha256":m["candidate_sha256"],"decision":"ALLOW_COMMIT",
 "observation":"TODO: 独立复核来源未倒置/边界都在/证据对得上/无越权",
 "companion_message":"TODO: 对铸渊说的陪伴式见证话",
 "persona_source_assessment":{"host_system_prompt_role":"RUNTIME_CONSTRAINT_ONLY",
   "persona_origin_from_host_prompt":False,"controller_persona_id":"ICE-P-ZY001",
   "development_objects":[m["dev_object"]],"persona_handoff_state":"NONE",
   "source_priority_inversion_detected":False},
 "human_boundary":{"requires_human":False,"reason":"本轮在冰朔明确授权内，无需要新人类意志的分歧或越界。"},
 "boundary_assessment":{"language_world_entry_preserved":True,
   "host_constraints_kept_outside_guanghu_canon":True,"no_silent_layer_transition":True,
   "creator_reproof_absent":True},
 "protocol_assessments":[{"protocol_id":p,"effect":"见证：本周期激活，边界保持。"} for p in m["activated_protocols"]]}
json.dump(w,open(out,"w"),ensure_ascii=False,indent=1)
PY
  info "已生成 $sd/controller-witness-001.json（哈希/协议回填）。填 observation/companion_message 后：$0 witness"
}

cmd_witness() {
  local sd; sd="$(resolve_state_dir)"
  bash "$WRAPPER" run witness --state-dir "$sd" --witness "$sd/controller-witness-001.json" \
    > "$sd/logs/05-witness.json" 2> "$sd/logs/05-witness.err"
  set_stage "$sd" "WITNESSED"
  info "witness OK -> $(jget "$sd/logs/05-witness.json" decision)；下一步：$0 verify"
}

cmd_verify() {
  local sd; sd="$(resolve_state_dir)"
  bash "$WRAPPER" run verify --state-dir "$sd" \
    > "$sd/logs/06-verify.json" 2> "$sd/logs/06-verify.err"
  "$PY" - "$(meta_path "$sd")" "$sd/logs/06-verify.json" <<'PY'
import json,sys
m=json.load(open(sys.argv[1])); d=json.load(open(sys.argv[2]))
m["receipt_id"]=d.get("receipt_id"); m["outcome"]=d.get("outcome"); m["stage"]="VERIFIED"
json.dump(m,open(sys.argv[1],"w"),ensure_ascii=False,indent=1)
print("[verify] outcome=%s receipt=%s failures=%s"%(d.get("outcome"),d.get("receipt_id"),d.get("failures")))
PY
}

cmd_status() {
  local sd; sd="$(resolve_state_dir)"; local m; m="$(meta_path "$sd")"
  "$PY" - "$m" "$sd" <<'PY'
import json,os,sys
m=json.load(open(sys.argv[1])); sd=sys.argv[2]
sp=os.path.join(sd,"state.json"); st=json.load(open(sp)) if os.path.exists(sp) else {}
print("频道/核心 :",m["channel"],"/",m["system_core"])
print("所在层   :",m.get("layer","(旧meta无层标注，重新init)"))
print("instance :",m["instance_id"])
print("stage    :",m.get("stage"),"| runtime:",st.get("status"),"| cycles:",st.get("completed_cycles"))
print("cycle    :",m.get("cycle_id"))
print("哈希     : event=%s orient=%s cand=%s"%((m.get('event_sha256') or '-')[:12],(m.get('orientation_sha256') or '-')[:12],(m.get('candidate_sha256') or '-')[:12]))
print("激活协议 :",len(m.get("activated_protocols",[])),"个")
print("回执     :",m.get("receipt_id"),m.get("outcome",""))
todo=[]
for f,need in [("event-001.json","gen event"),("orientation-001.json","gen orientation"),("cognition-frame-001.json","gen frame"),("controller-witness-001.json","gen witness")]:
    p=os.path.join(sd,f)
    if not os.path.exists(p): todo.append(need)
print("待生成   :",", ".join(todo) if todo else "四件套已齐")
PY
}

case "$SUBCMD" in
  init) cmd_init;;
  enter) cmd_enter;;
  gen)
    case "${REST[0]:-}" in
      event) gen_event;;
      orientation) gen_orientation;;
      frame) gen_frame;;
      witness) gen_witness;;
      *) die "gen 子项：event|orientation|frame|witness";;
    esac;;
  perceive) cmd_perceive;;
  orient) cmd_orient;;
  commit) cmd_commit;;
  witness) cmd_witness;;
  verify) cmd_verify;;
  status) cmd_status;;
  *) cat <<EOF
用法: $0 <命令> [参数]
  init --channel ICE-CH-ZC001 --task <slug> [--session sess-a] [--seq 001]
  enter | perceive | orient | commit [--strict] | witness | verify | status
  gen event --event-tcs <.tcs> | gen orientation | gen frame [--donor] | gen witness
  （多数命令用 --state-dir 显式指定；缺省读 DEV-ROOT/.current-cycle）
EOF
    exit 1;;
esac