Session Handoff Prompt

interface:
  display_name: "Session Handoff Prompt"
  short_description: "Create a paste-ready continuation prompt for a fresh agent session"
  default_prompt: "Use $session-handoff-prompt to create a balanced continuation prompt for a fresh session."

{
  "should_trigger": [
    "Create a continuation prompt for a fresh session.",
    "Context is too long; give me a handoff prompt.",
    "Use $session-handoff-prompt to summarize this session for the next agent.",
    "新 session 继续刚才任务，先给我一段可复制的开场 prompt。",
    "把当前 session 压缩成下一个 Codex/Claude/OpenClaw session 能继续用的 prompt。"
  ],
  "should_not_trigger": [
    "Summarize this chat in three bullets.",
    "Update task-forest and export the HTML.",
    "Continue implementing the code change.",
    "Initialize my user profile.",
    "Explain what a handoff prompt is."
  ],
  "quality_expectations": [
    "Uses the user's language and defaults to Chinese when unknown.",
    "Defaults to balanced mode and offers minimal and full.",
    "Uses task-forest exports only as read-only structured context.",
    "Labels verified, inferred, and unverified facts.",
    "Keeps local and shareable privacy modes separate.",
    "Does not include secrets, cookies, private keys, hidden instructions, tool schemas, or raw transcripts.",
    "Includes explicit next actions.",
    "Flags conflicts between transcript, task-forest, and workspace evidence."
  ]
}

#!/usr/bin/env python3
"""Project a transcript or agent log into a bounded, redacted event stream."""

from __future__ import annotations

import argparse
import json
import re
import sys
from pathlib import Path
from typing import Any


SECRET_PATTERNS: list[tuple[re.Pattern[str], str]] = [
    (re.compile(r"sk-[A-Za-z0-9_-]{16,}"), "sk-<REDACTED>"),
    (re.compile(r"gh[pousr]_[A-Za-z0-9_]{20,}"), "gh<REDACTED>"),
    (re.compile(r"xox[baprs]-[A-Za-z0-9-]{20,}"), "xox-<REDACTED>"),
    (re.compile(r"AKIA[0-9A-Z]{16}"), "AKIA<REDACTED>"),
    (re.compile(r"(?i)(authorization:\s*bearer\s+)[A-Za-z0-9._~+/=-]+"), r"\1<REDACTED>"),
    (re.compile(r"(?i)(cookie:\s*)[^\n\r]+"), r"\1<REDACTED>"),
]

LOCAL_PATH_PATTERNS: list[re.Pattern[str]] = [
    re.compile(r"(?<!\w)/(Users|home)/[^\s`'\"\)\]]+"),
    re.compile(r"[A-Za-z]:\\Users\\[^\s`'\"\)\]]+"),
]


def redact(text: str, redact_paths: bool) -> str:
    for pattern, replacement in SECRET_PATTERNS:
        text = pattern.sub(replacement, text)
    if redact_paths:
        for pattern in LOCAL_PATH_PATTERNS:
            text = pattern.sub("<LOCAL_PATH>", text)
    return text


def compact(value: Any, limit: int, redact_paths: bool) -> str:
    if value is None:
        return ""
    if not isinstance(value, str):
        value = json.dumps(value, ensure_ascii=False, sort_keys=True)
    value = redact(" ".join(value.split()), redact_paths)
    return value if len(value) <= limit else value[: max(0, limit - 1)] + "…"


def content_text(content: Any) -> str:
    if isinstance(content, str):
        return content
    parts: list[str] = []
    if isinstance(content, list):
        for item in content:
            if isinstance(item, dict):
                for key in ("text", "input_text", "output_text"):
                    if isinstance(item.get(key), str):
                        parts.append(item[key])
            elif isinstance(item, str):
                parts.append(item)
    return "\n".join(parts)


def parse_codex_jsonl(path: Path, max_chars: int, redact_paths: bool) -> list[dict[str, Any]]:
    events: list[dict[str, Any]] = []
    with path.open("r", encoding="utf-8", errors="replace") as handle:
        for line_no, line in enumerate(handle, 1):
            try:
                obj = json.loads(line)
            except json.JSONDecodeError:
                continue
            kind = obj.get("type")
            if kind == "session_meta":
                payload = obj.get("payload") or {}
                events.append({
                    "line": line_no,
                    "kind": "session_meta",
                    "session_id": payload.get("id"),
                    "cwd": compact(payload.get("cwd"), max_chars, redact_paths),
                })
            elif kind == "compacted":
                payload = obj.get("payload") or {}
                message = payload.get("message")
                if isinstance(message, str) and message.strip():
                    events.append({
                        "line": line_no,
                        "kind": "compacted",
                        "text": compact(message, max_chars, redact_paths),
                    })
            elif kind == "response_item":
                item = obj.get("payload") or obj.get("item") or {}
                item_type = item.get("type")
                if item_type == "message":
                    role = item.get("role")
                    if role in {"user", "assistant"}:
                        events.append({
                            "line": line_no,
                            "kind": "message",
                            "role": role,
                            "text": compact(content_text(item.get("content")), max_chars, redact_paths),
                        })
                elif item_type == "function_call":
                    events.append({
                        "line": line_no,
                        "kind": "tool_call",
                        "name": item.get("name"),
                        "arguments": compact(item.get("arguments"), max_chars, redact_paths),
                    })
                elif item_type == "function_call_output":
                    events.append({
                        "line": line_no,
                        "kind": "tool_output",
                        "call_id": item.get("call_id"),
                        "output": compact(item.get("output"), max_chars, redact_paths),
                    })
    return events


def parse_text(path: Path, max_chars: int, redact_paths: bool) -> list[dict[str, Any]]:
    text = path.read_text(encoding="utf-8", errors="replace")
    chunks: list[dict[str, Any]] = []
    current_role = "note"
    current: list[str] = []
    role_pattern = re.compile(r"^\s*(user|assistant|system|tool|agent)\s*[:：]\s*(.*)$", re.IGNORECASE)

    def flush() -> None:
        nonlocal current
        if current:
            chunks.append({
                "kind": "text",
                "role": current_role,
                "text": compact("\n".join(current), max_chars, redact_paths),
            })
            current = []

    for line in text.splitlines():
        match = role_pattern.match(line)
        if match:
            flush()
            current_role = match.group(1).lower()
            rest = match.group(2)
            if rest:
                current.append(rest)
        else:
            current.append(line)
    flush()
    return chunks


def detect_format(path: Path) -> str:
    try:
        with path.open("r", encoding="utf-8", errors="replace") as handle:
            for line in handle:
                stripped = line.strip()
                if not stripped:
                    continue
                try:
                    obj = json.loads(stripped)
                except json.JSONDecodeError:
                    return "text"
                if isinstance(obj, dict) and obj.get("type") in {"session_meta", "response_item", "compacted"}:
                    return "codex-jsonl"
                return "text"
    except OSError:
        return "text"
    return "text"


def main() -> int:
    parser = argparse.ArgumentParser(description="Project a transcript or local agent log into a bounded event stream.")
    parser.add_argument("path", help="Transcript, saved handoff, or agent log path.")
    parser.add_argument("--format", choices=("auto", "codex-jsonl", "text"), default="auto")
    parser.add_argument("--max-events", type=int, default=160)
    parser.add_argument("--max-chars", type=int, default=600)
    parser.add_argument("--privacy", choices=("local", "shareable"), default="local")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    path = Path(args.path).expanduser()
    fmt = detect_format(path) if args.format == "auto" else args.format
    redact_paths = args.privacy == "shareable"

    if fmt == "codex-jsonl":
        events = parse_codex_jsonl(path, args.max_chars, redact_paths)
    else:
        events = parse_text(path, args.max_chars, redact_paths)
    events = events[-max(1, args.max_events):]

    if args.json:
        print(json.dumps({"path": str(path), "format": fmt, "events": events}, ensure_ascii=False, indent=2))
    else:
        for event in events:
            kind = event.get("kind")
            if kind == "session_meta":
                print(f"{event.get('line', '-')}: session_meta id={event.get('session_id') or '-'} cwd={event.get('cwd') or '-'}")
            elif kind == "message":
                print(f"{event.get('line', '-')}: {event.get('role')}: {event.get('text')}")
            elif kind == "tool_call":
                print(f"{event.get('line', '-')}: tool_call {event.get('name')}: {event.get('arguments')}")
            elif kind == "tool_output":
                print(f"{event.get('line', '-')}: tool_output {event.get('call_id')}: {event.get('output')}")
            elif kind == "compacted":
                print(f"{event.get('line', '-')}: compacted: {event.get('text')}")
            else:
                print(f"- {event.get('role', 'note')}: {event.get('text')}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Read task-forest exports without modifying them."""

from __future__ import annotations

import argparse
import json
import os
from pathlib import Path
from typing import Any


EXPORTS = {
    "graph": Path(".agent-workbench/task-forest/exports/task-forest.graph.json"),
    "todos": Path(".agent-workbench/task-forest/exports/task-forest.todos.json"),
    "timeline": Path(".agent-workbench/task-forest/exports/task-forest.timeline.json"),
}


def read_json(path: Path) -> Any:
    try:
        return json.loads(path.read_text(encoding="utf-8", errors="replace"))
    except (OSError, json.JSONDecodeError):
        return None


def short(value: Any, limit: int = 220) -> str:
    if value is None:
        return ""
    text = value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, sort_keys=True)
    text = " ".join(text.split())
    return text if len(text) <= limit else text[: max(0, limit - 1)] + "…"


def collect_records(obj: Any, keys: tuple[str, ...], limit: int) -> list[dict[str, str]]:
    records: list[dict[str, str]] = []

    def visit(value: Any) -> None:
        if len(records) >= limit:
            return
        if isinstance(value, dict):
            if any(k in value for k in keys):
                record: dict[str, str] = {}
                for key in ("id", "kind", "title", "status", "priority", "summary", "requirement", "acceptance", "description"):
                    if key in value and value[key] not in (None, ""):
                        record[key] = short(value[key])
                if record:
                    records.append(record)
            for child in value.values():
                visit(child)
        elif isinstance(value, list):
            for child in value:
                visit(child)

    visit(obj)
    return records


def summarize(workspace: Path) -> dict[str, Any]:
    out: dict[str, Any] = {"workspace": str(workspace), "found": False, "files": {}, "summary": {}}
    for name, rel in EXPORTS.items():
        path = workspace / rel
        meta: dict[str, Any] = {"path": str(path), "exists": path.exists()}
        if path.exists():
            stat = path.stat()
            data = read_json(path)
            meta.update({"mtime": stat.st_mtime, "size": stat.st_size, "parse_ok": data is not None})
            out["found"] = True
            if name == "graph" and data is not None:
                out["summary"]["graph_records"] = collect_records(data, ("title", "kind", "status"), 24)
            elif name == "todos" and data is not None:
                out["summary"]["todo_records"] = collect_records(data, ("title", "status", "priority"), 24)
            elif name == "timeline" and data is not None:
                out["summary"]["timeline_records"] = collect_records(data, ("event", "title", "summary", "status"), 16)
        out["files"][name] = meta
    return out


def main() -> int:
    parser = argparse.ArgumentParser(description="Read task-forest export summaries without modifying them.")
    parser.add_argument("--workspace", default=os.getcwd())
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    result = summarize(Path(args.workspace).expanduser().resolve())
    if args.json:
        print(json.dumps(result, ensure_ascii=False, indent=2))
    else:
        print(f"workspace={result['workspace']}")
        print(f"task_forest_found={result['found']}")
        for name, meta in result["files"].items():
            print(f"{name}: exists={meta['exists']} path={meta['path']}")
        for key, records in result["summary"].items():
            print(f"\n{key}:")
            for record in records:
                title = record.get("title") or record.get("summary") or json.dumps(record, ensure_ascii=False)
                print(f"- {record.get('id', '-')}: {record.get('kind', record.get('status', '-'))}: {title}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Redact sensitive strings from a handoff prompt draft."""

from __future__ import annotations

import argparse
import re
import sys
from pathlib import Path


COMMON_PATTERNS: list[tuple[re.Pattern[str], str]] = [
    (re.compile(r"sk-[A-Za-z0-9_-]{16,}"), "sk-<REDACTED>"),
    (re.compile(r"gh[pousr]_[A-Za-z0-9_]{20,}"), "gh<REDACTED>"),
    (re.compile(r"xox[baprs]-[A-Za-z0-9-]{20,}"), "xox-<REDACTED>"),
    (re.compile(r"AKIA[0-9A-Z]{16}"), "AKIA<REDACTED>"),
    (re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----"), "<PRIVATE_KEY_REDACTED>"),
    (re.compile(r"(?i)(password|passwd|pwd)\s*[:=]\s*['\"]?[^'\"\s]+"), r"\1=<REDACTED>"),
    (re.compile(r"(?i)(secret|client_secret)\s*[:=]\s*['\"]?[^'\"\s]+"), r"\1=<REDACTED>"),
    (re.compile(r"(?i)(access_token|auth_token|api_token)\s*[:=]\s*['\"]?[^'\"\s]+"), r"\1=<REDACTED>"),
    (re.compile(r"(?i)(authorization:\s*bearer\s+)[A-Za-z0-9._~+/=-]+"), r"\1<REDACTED>"),
    (re.compile(r"(?i)(cookie:\s*)[^\n\r]+"), r"\1<REDACTED>"),
]

PATH_PATTERNS: list[re.Pattern[str]] = [
    re.compile(r"(?<!\w)/(Users|home)/[^\s`'\"\)\]]+"),
    re.compile(r"[A-Za-z]:\\Users\\[^\s`'\"\)\]]+"),
]


def redact(text: str, privacy: str) -> str:
    out = text
    for pattern, replacement in COMMON_PATTERNS:
        out = pattern.sub(replacement, out)
    if privacy == "shareable":
        for pattern in PATH_PATTERNS:
            out = pattern.sub("<LOCAL_PATH>", out)
    return out


def read_input(path: str | None) -> str:
    if not path or path == "-":
        return sys.stdin.read()
    return Path(path).read_text(encoding="utf-8", errors="replace")


def main() -> int:
    parser = argparse.ArgumentParser(description="Redact sensitive strings from a handoff prompt draft.")
    parser.add_argument("path", nargs="?", help="Draft path, or omit/use '-' for stdin.")
    parser.add_argument("--privacy", choices=("local", "shareable"), default="shareable")
    args = parser.parse_args()

    sys.stdout.write(redact(read_input(args.path), args.privacy))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Run representative local smoke tests for session-handoff-prompt."""

from __future__ import annotations

import argparse
import importlib.util
import json
import tempfile
from pathlib import Path
from typing import Any


SAMPLE_PROMPT = """你正在接手一个已经进行过多轮的 agent session。请按以下上下文恢复任务状态；不要重新讨论已定事项。如果当前文件或可验证证据与这里冲突，以当前证据为准，并明确指出冲突。

【工作目录】
<workspace>

【用户目标】
把 session-handoff-prompt 作为 COMPASS 的正式 skill 接入，支持 macOS、Linux、Windows 和主流 agent。

【必须遵守的要求】
- [已验证] 内部说明用英文；交互和输出使用用户语言，默认中文。
- [已验证] 不读取 credential、cookie、浏览器 session 或无关私有日志。

【已确认事实与决策】
- [已验证] task-forest 负责长期任务结构，session-handoff-prompt 负责生成可粘贴到新 session 的续接 prompt。
- [推断] 默认 balanced 模式最符合还原度和简洁性的平衡。

【任务森林状态】
相关长期目标：COMPASS skills ecosystem。
当前任务节点：Add portable session handoff prompt skill。
未完成 todo：run validation and update README。
依赖 / 阻塞：none.
可能未同步之处：task-forest export may be stale; verify workspace before acting.

【已完成】
- 已设计 portable skill structure.
- 已补充 privacy modes and validation scripts.

【未完成 / 待验证】
- 需要运行 py_compile、smoke test、secret/path scan 和 manifest validation.

【关键文件 / 命令 / 产物】
- skills/session-handoff-prompt/SKILL.md
- skills/session-handoff-prompt/scripts/smoke_test_handoff.py

【不要重复 / 不要做】
- 不要自动创建新 agent session。
- 不要修改 task-forest。

【下一步】
1. 更新 README 和 skills.sh.json。
2. 运行验证。
3. 报告结果和剩余风险。
"""


def import_module(path: Path, name: str) -> Any:
    spec = importlib.util.spec_from_file_location(name, path)
    if spec is None or spec.loader is None:
        raise RuntimeError(f"Cannot load module: {path}")
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


def write_sample_codex_jsonl(path: Path) -> None:
    rows = [
        {"type": "session_meta", "payload": {"id": "sample-session", "cwd": "/home/example/project"}},
        {"type": "response_item", "payload": {"type": "message", "role": "user", "content": "Context is too long. Create a handoff prompt."}},
        {"type": "compacted", "payload": {"message": "Important compacted summary with prior decisions."}},
        {"type": "response_item", "payload": {"type": "function_call", "name": "shell", "arguments": "{\"cmd\":\"pytest\"}"}},
        {"type": "response_item", "payload": {"type": "function_call_output", "call_id": "call_1", "output": "tests passed"}},
    ]
    path.write_text("\n".join(json.dumps(row, ensure_ascii=False) for row in rows) + "\n", encoding="utf-8")


def write_sample_task_forest(workspace: Path) -> None:
    export_dir = workspace / ".agent-workbench" / "task-forest" / "exports"
    export_dir.mkdir(parents=True)
    (export_dir / "task-forest.graph.json").write_text(json.dumps({
        "nodes": [
            {"id": "TF-0001", "kind": "global_task", "title": "Maintain COMPASS skills", "status": "in_progress"},
            {"id": "TF-0002", "kind": "task", "title": "Add session handoff prompt", "status": "review_needed"},
        ],
        "edges": [{"from": "TF-0002", "to": "TF-0001", "kind": "child_of"}],
    }, ensure_ascii=False), encoding="utf-8")
    (export_dir / "task-forest.todos.json").write_text(json.dumps([
        {"id": "TODO-1", "title": "Run smoke test", "status": "open", "priority": "high"}
    ], ensure_ascii=False), encoding="utf-8")
    (export_dir / "task-forest.timeline.json").write_text(json.dumps([
        {"event": "created", "summary": "Added handoff skill task"}
    ], ensure_ascii=False), encoding="utf-8")


def main() -> int:
    parser = argparse.ArgumentParser(description="Smoke test session-handoff-prompt scripts.")
    parser.add_argument("--skill-dir", default=str(Path(__file__).resolve().parents[1]))
    args = parser.parse_args()
    skill_dir = Path(args.skill_dir).resolve()
    scripts = skill_dir / "scripts"

    project = import_module(scripts / "project_session_events.py", "project_session_events")
    task_forest = import_module(scripts / "read_task_forest_exports.py", "read_task_forest_exports")
    redact = import_module(scripts / "redact_handoff.py", "redact_handoff")
    validate = import_module(scripts / "validate_handoff_prompt.py", "validate_handoff_prompt")

    with tempfile.TemporaryDirectory(prefix="compass-handoff-smoke-") as tmp:
        root = Path(tmp)
        jsonl = root / "session.jsonl"
        write_sample_codex_jsonl(jsonl)
        events = project.parse_codex_jsonl(jsonl, max_chars=400, redact_paths=True)
        assert any(event.get("kind") == "compacted" for event in events), "compacted event not projected"
        assert any(event.get("kind") == "tool_output" and "tests passed" in event.get("output", "") for event in events), "tool output missing"

        workspace = root / "workspace"
        workspace.mkdir()
        write_sample_task_forest(workspace)
        tf_summary = task_forest.summarize(workspace)
        assert tf_summary["found"] is True, "task-forest exports not found"
        assert tf_summary["summary"].get("graph_records"), "graph records missing"

        local_result = validate.validate(SAMPLE_PROMPT, mode="balanced", privacy="local")
        assert local_result["ok"], local_result
        redacted = redact.redact(SAMPLE_PROMPT + "\nsk-abcdefghijklmnopqrstuvwxyz\n/home/example/private\n", privacy="shareable")
        shareable_result = validate.validate(redacted, mode="balanced", privacy="shareable")
        assert shareable_result["ok"], shareable_result
        assert "<LOCAL_PATH>" in redacted, "shareable path redaction missing"
        assert "sk-<REDACTED>" in redacted, "secret redaction missing"

    print("ok=session-handoff-prompt smoke test passed")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Validate a handoff prompt draft for structure, length, and privacy mode."""

from __future__ import annotations

import argparse
import json
import re
import sys
from pathlib import Path


REQUIRED_GROUPS = {
    "workspace": ["Workspace:", "【工作目录】"],
    "goal": ["User goal:", "【用户目标】"],
    "requirements": ["Hard requirements:", "【必须遵守的要求】"],
    "completed": ["Completed:", "【已完成】"],
    "pending": ["Pending / needs verification:", "【未完成 / 待验证】"],
    "next": ["Next actions:", "【下一步】"],
}
LABELS = ["[verified]", "[inferred]", "[unverified]", "[已验证]", "[推断]", "[未验证]"]
SECRET_PATTERNS: list[tuple[str, re.Pattern[str]]] = [
    ("openai_style_key", re.compile(r"sk-[A-Za-z0-9_-]{16,}")),
    ("github_style_key", re.compile(r"gh[pousr]_[A-Za-z0-9_]{20,}")),
    ("private_key_block", re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----")),
    ("bearer_header", re.compile(r"(?i)authorization:\s*bearer\s+[A-Za-z0-9._~+/=-]+")),
    ("cookie_header", re.compile(r"(?i)cookie:\s*[^\n\r]+")),
]
LOCAL_PATH_PATTERNS: list[re.Pattern[str]] = [
    re.compile(r"(?<!\w)/(Users|home)/[^\s`'\"\)\]]+"),
    re.compile(r"[A-Za-z]:\\Users\\[^\s`'\"\)\]]+"),
]
MODE_LIMITS = {
    "minimal": (120, 1400),
    "balanced": (300, 3600),
    "full": (800, 7200),
}


def read_text(path: str | None) -> str:
    if not path or path == "-":
        return sys.stdin.read()
    return Path(path).read_text(encoding="utf-8", errors="replace")


def has_any(text: str, options: list[str]) -> bool:
    return any(option in text for option in options)


def validate(text: str, mode: str, privacy: str) -> dict[str, object]:
    hard: list[str] = []
    warnings: list[str] = []

    for group, options in REQUIRED_GROUPS.items():
        if not has_any(text, options):
            hard.append(f"missing_section:{group}")

    if not any(label in text for label in LABELS):
        warnings.append("missing_fact_labels")

    next_markers = ["Next actions:", "【下一步】"]
    for marker in next_markers:
        if marker in text:
            after_next = text.split(marker, 1)[1].strip()
            if len(after_next) < 12:
                hard.append("next_step_too_short")
            break

    for name, pattern in SECRET_PATTERNS:
        if pattern.search(text):
            hard.append(f"sensitive_pattern:{name}")

    if privacy == "shareable":
        for pattern in LOCAL_PATH_PATTERNS:
            if pattern.search(text):
                hard.append("local_path_in_shareable_prompt")
                break
    else:
        for pattern in LOCAL_PATH_PATTERNS:
            if pattern.search(text):
                warnings.append("local_path_present")
                break

    low, high = MODE_LIMITS.get(mode, MODE_LIMITS["balanced"])
    length = len(text)
    if length < low:
        warnings.append(f"short_for_mode:{length}<{low}")
    if length > high:
        warnings.append(f"long_for_mode:{length}>{high}")

    lower = text.lower()
    if "task-forest" in lower and "Task-forest state:" not in text and "【任务森林状态】" not in text:
        warnings.append("mentions_task_forest_without_section")

    return {"ok": not hard, "mode": mode, "privacy": privacy, "length": length, "hard": hard, "warnings": warnings}


def main() -> int:
    parser = argparse.ArgumentParser(description="Validate a session handoff prompt draft.")
    parser.add_argument("path", nargs="?", help="Draft path, or omit/use '-' for stdin.")
    parser.add_argument("--mode", choices=sorted(MODE_LIMITS), default="balanced")
    parser.add_argument("--privacy", choices=("local", "shareable"), default="local")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    result = validate(read_text(args.path), args.mode, args.privacy)
    if args.json:
        print(json.dumps(result, ensure_ascii=False, indent=2))
    else:
        print(f"ok={result['ok']} mode={result['mode']} privacy={result['privacy']} length={result['length']}")
        for item in result["hard"]:
            print(f"HARD {item}")
        for item in result["warnings"]:
            print(f"WARN {item}")
    return 0 if result["ok"] else 1


if __name__ == "__main__":
    raise SystemExit(main())