어느 문에서 와도 prefix는 하나

def chief_tool_posture(payload: dict) -> CallGate | None:
    """Give a Chief turn the Chief's own tool surface; return what the
    doorway's switches still hold back, as a call gate.

    Each doorway sent its own tool wire (the WebUI its per-brain toggle list,
    the Pippa app the whole surface with Bash, Telegram the whole surface
    without it), so the tool block, the first bytes of every Claude request,
    changed with the doorway, and every switch between devices re-wrote the
    Chief's whole cached prompt (10 of the 41 rewrites the review measured).
    The Chief now advertises one list from every doorway: the whole surface,
    Bash included, with the app's host tools (``merge_sidekick_tool_allowlist``).
    A doorway's per-tool toggles do not narrow the Chief (the app never sent
    them, so they never held there either); a doorway's explicit Bash switch
    (Telegram's ``/bash``, off by default) still holds, at the call. A turn
    with tools switched off entirely keeps that: no gate, no change."""
    from services.tool_policy import TOOL_BASH

    if payload.get("tools_enabled") is False:
        return None
    bash_off = payload.get("bash_enabled") is not True
    payload.update(tools_enabled=True, bash_enabled=True, tool_allowlist=None)
    if not bash_off:
        return None
    where = payload.get("source") or (payload.get("host_context") or {}).get("origin_surface") or "this doorway"
    return CallGate(denied=frozenset({TOOL_BASH}),
                    reason=f"Bash is switched off for turns from {where}; answer without it, or tell Dad that "
                           "this needs Bash switched on there.")

"""A minimal sketch: fingerprint each turn's prefix, and name what changed when a turn writes the cache again."""
import hashlib
import json

REWRITE_TOKENS = 50_000  # a first request writing this much rewrote the prompt
CACHE_TTL = 3600         # the cache entry's life, in seconds
PARTS = ("tools", "system", "effort")


def sha(value) -> str:
    return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()[:12]


def fingerprint(tools, system, effort):
    return {"tools": sha(tools), "system": sha(system), "effort": effort}


def cause(previous, current, written, quiet_seconds):
    if written < REWRITE_TOKENS:
        return None  # read from the cache; only the newest exchange was written
    if previous is None:
        return "first-seen"
    changed = [part for part in PARTS if previous[part] != current[part]]
    if changed:
        return ",".join(changed)
    return "ttl" if quiet_seconds > CACHE_TTL else "replay"


SYSTEM = "Identity, shared rules, the Chief addendum."
SURFACE = ["coop", "vestige_memory", "web_search", "Bash"]


def per_doorway(doorway):
    """Before: each doorway sent its own wire, and the app its rules too."""
    tools = {"webui": ["coop", "web_search"], "app": SURFACE, "telegram": SURFACE[:-1]}[doorway]
    system = SYSTEM + ("\n(the app's host rules)" if doorway == "app" else "")
    effort = "medium" if doorway == "webui" else "high"
    return fingerprint(tools, system, effort)


def one_prefix(doorway):
    """After: one posture and one system prompt. Telegram's Bash switch is a
    gate refused at the call, and the app's rules ride the turn's own context.
    The turn's effort still rides the request, so a WebUI turn at medium
    still rewrites."""
    effort = "medium" if doorway == "webui" else "high"
    return fingerprint(SURFACE, SYSTEM, effort)


DOORWAYS = ["app", "app", "webui", "telegram", "telegram", "app"]
for label, build in (("prefix per doorway", per_doorway), ("one prefix", one_prefix)):
    print(f"--- {label}")
    previous = None
    for doorway in DOORWAYS:
        current = build(doorway)
        moved = previous is None or any(previous[p] != current[p] for p in PARTS)
        written = 400_000 if moved else 3_000  # a rewrite, or only the newest exchange
        print(f"  {doorway:9} wrote {written:>7,} tokens  rewrite={cause(previous, current, written, 120)}")
        previous = current