"""Compose publication 6 v2 from verified v1 plus six authorized saved-human masks.

No matching, synthetic requests, new human edits, database writes or publication.
The original generator and every existing proposal/target asset remain frozen.
"""
from __future__ import annotations

import argparse
from collections import Counter
from contextlib import closing
import copy
import hashlib
import html
import json
from pathlib import Path
import shutil
from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit

from . import mask_quota_completion as original
from .cluster_targets import digest, load_dataset, protected_snapshot, target_key
from .mask_template_transfer import ImageEvidence, annotation_inventory
from .pose_review_geometry import canonical, polygon_value

PROJECT = original.PROJECT
SOURCE = PROJECT/'outputs/pallet_mask_quota_completion_v1'
OUTPUT = PROJECT/'outputs/pallet_mask_quota_completion_v2'
DIAGNOSTIC = PROJECT/'outputs/pallet_mask_class10_completion_diagnostic_v1/existing_human_reuse.jsonl'
VERSION = 'authorized_saved_human_quota_extension_v1'
SUPPLEMENT_KEYS = frozenset({
    '5a50c8a3f3b203f4a73302c5', '769e10f2f395d177eee6ee8f',
    '77c50239649469197cae6b04', '82570f9f6b30bb2c1d696306',
    '8515501d58bc1f637a826f4b', 'b62526c40d7f972094b41bdb',
})
REBUILT = frozenset({
    'manifest.json', 'proposals.jsonl', 'manual_proposals.jsonl', 'manual_source_records.jsonl',
    'outcomes.jsonl', 'template_inventory.json', 'protected_targets.json', 'shortfalls.json',
    'report_zh.html', 'report-font.otf', 'font_coverage.json', 'snapshot_manifest.json',
    'used_image_hashes.json', 'artifact_hashes.json', 'GENERATION_HANDOFF.md',
    'generation_validation.json', 'validation_report.json', 'verification.json',
})
read_jsonl, write_jsonl = original.read_jsonl, original.write_jsonl
write_json, sha = original.write_json, original.sha


def read_json(path):
    return json.loads(Path(path).read_text())


def indexed(values):
    result = {v['target_key']: v for v in values}
    if len(result) != len(values):
        raise ValueError('Duplicate target key')
    return result


def file_inventory(directory):
    result = {}
    for path in sorted(Path(directory).rglob('*')):
        if path.is_symlink():
            raise ValueError('Source generation contains a symlink')
        if path.is_file():
            result[str(path.relative_to(directory))] = digest(path)
    return result


def safe_member(directory, name):
    path = Path(directory)/name
    if Path(name).is_absolute() or '..' in Path(name).parts or not path.resolve().is_relative_to(directory):
        raise ValueError('Unsafe artifact path')
    return path


def verified_source(source):
    """Refuse to create any output until the coordinating verifier's seal exists."""
    source = Path(source).resolve()
    if not (source/'verification.json').is_file():
        raise ValueError('Source v1 verification.json is absent; wait for independent verification')
    manifest, seal = read_json(source/'manifest.json'), read_json(source/'verification.json')
    if (seal.get('state') != 'passed' or seal.get('publication_version') != 6 or
            seal.get('proposals_verified') != 231 or manifest.get('publication_version') != 6 or
            manifest.get('proposals') != 231 or manifest.get('manual_proposals') != 24 or
            manifest.get('new_proposals') != 67 or manifest.get('previous_proposals') != 140 or
            manifest.get('generation_templates') != 175 or
            seal.get('manifest_sha256') != digest(source/'manifest.json') or
            seal.get('proposals_sha256') != manifest.get('proposals_sha256')):
        raise ValueError('Source v1 independent verification identity differs')
    for name, field in (
            ('proposals.jsonl', 'proposals_sha256'), ('new_proposals.jsonl', 'new_proposals_sha256'),
            ('manual_proposals.jsonl', 'manual_proposals_sha256'),
            ('manual_source_records.jsonl', 'manual_source_records_sha256'),
            ('template_inventory.json', 'template_inventory_sha256'), ('requests.jsonl', 'requests_sha256')):
        if digest(source/name) != manifest[field]:
            raise ValueError('Source generation bound file changed: '+name)
    for name, expected in manifest['frozen_code_sha256'].items():
        if digest(safe_member(PROJECT, name)) != expected:
            raise ValueError('Frozen original generator/algorithm changed: '+name)
    if digest(PROJECT/'pallet/mask_quota_completion.py') != manifest['code_sha256']:
        raise ValueError('Primary generator code provenance changed')
    if (digest(source/'reviews_snapshot.sqlite3') != manifest['snapshot_sha256'] or
            digest(source/'gallery_reviews_snapshot.sqlite3') != manifest['gallery_snapshot_sha256']):
        raise ValueError('Source generation snapshot changed')
    for name, expected in read_json(source/'artifact_hashes.json').items():
        if digest(safe_member(source, name)) != expected:
            raise ValueError('Source generation artifact changed: '+name)
    return manifest, file_inventory(source)


def load_formal_evidence(manifest):
    formal = Path(read_json(PROJECT/'configs/active_formal_dataset.json')['dataset'])
    classification = PROJECT/'outputs/pallet_appearance_center_reclassification_v1/targets.jsonl'
    if (digest(formal/'manifest.json') != manifest['formal_manifest_sha256'] or
            digest(classification) != manifest['classification_sha256']):
        raise ValueError('Formal dataset/classification differs from v1')
    annotations, sources = load_dataset(formal)
    rows = indexed(read_jsonl(classification))
    identities = {target_key(a['frame_id'], i): (a, box)
        for a in annotations for i, box in enumerate(a['boxes'])}
    if set(identities) != set(rows):
        raise ValueError('Formal/classification target coverage differs')
    for key, row in rows.items():
        a, box = identities[key]; source = sources[row['frame_id']]
        if (row['bbox'] != box or any(row[k] != a[k] for k in ('frame_id', 'split', 'group_id')) or
                row['source_pcd_sha256'] != source['source_anchor_hash'] or
                row['policy_id'] != source['sensor_policy']['policy_id']):
            raise ValueError('Formal/classification source identity differs')
        row['size'] = source['size']
    return formal, rows, ImageEvidence(formal, rows, sources)


def original_pose_url(manual, key):
    url = next((p.get('original_pose_url') for p in manual if p.get('original_pose_url')), None)
    if url is None:
        raise ValueError('Original pose link unavailable')
    parsed = urlsplit(url)
    query = [(k, v) for k, v in parse_qsl(parsed.query) if k != 'target']
    return urlunsplit(parsed._replace(query=urlencode(query+[('target', key)])))


def supplement_proposals(records, templates, current, rows, combined, manual, manifest, diagnostic_sha):
    """Six explicit existing human records; never invent pending worklist requests."""
    if set(indexed(records)) != SUPPLEMENT_KEYS:
        raise ValueError('Expected exactly the six explicitly authorized human source keys')
    existing = indexed(combined)
    frames = {p['source']['frame_id'] for p in combined}
    result = []
    for record in sorted(records, key=lambda r: r['target_key']):
        key = record['target_key']; row = rows[key]
        t, value = templates.get(key), current.get(key)
        if key in existing or row['frame_id'] in frames:
            raise ValueError('Saved supplement repeats a cumulative target/frame')
        if (t is None or t.get('origin') != original.POSE_ORIGIN or value is None or
                value.get('state') in ('deleted', 'deferred') or
                row['final_class_id'] != 10 or record['class_id'] != 10):
            raise ValueError('Supplement is not an active original human Class 10 mask')
        if (len(value.get('polygon', [])) <= 4 or value['polygon'] != t['polygon'] or
                value['revision'] != t['revision'] or sha(value) != t['current_payload_sha256'] or
                record['current_payload'] != value or record['source'] != row or
                record['polygon'] != value['polygon'] or record['vertex_count'] != len(value['polygon']) or
                record['template'] != original.template_metadata(t)):
            raise ValueError('Supplement saved polygon/current/template differs')
        for field in ('target_key', 'frame_id', 'split', 'group_id', 'target_id', 'box_index',
                'bbox', 'size', 'policy_id', 'source_pcd_sha256'):
            if value['source'][field] != row[field]:
                raise ValueError('Supplement saved source identity differs: '+field)
        for field in original.FALSE_FLAGS:
            if value.get(field, False) is not False or record.get(field) is not False:
                raise ValueError('Supplement claims confirmation or training/robot eligibility')
        if (record['snapshot_sha256'] != manifest['snapshot_sha256'] or
                record['formal_manifest_sha256'] != manifest['formal_manifest_sha256'] or
                record['class_assignments_sha256'] != manifest['classification_sha256'] or
                record['current_payload_sha256'] != sha(value) or
                record.get('machine_transfer_performed') is not False or
                record.get('new_human_edit_created') is not False or record.get('metrics') != {}):
            raise ValueError('Supplement diagnostic binding or human-origin claims differ')
        polygon_value(value['polygon'], *row['size'])
        frames.add(row['frame_id'])
        result.append(dict(schema=original.MANUAL_SCHEMA, origin=original.POSE_ORIGIN,
            target_key=key, class_id=10, source=row, polygon=value['polygon'], vertex_count=len(value['polygon']),
            status='human_edited_draft_pending_confirmation', human_edited=True,
            source_label_kind='human_mask_source_manual_template_draft',
            manual_source_kind='authorized_existing_human_mask_reuse',
            **dict.fromkeys(original.FALSE_FLAGS, False), pose_snapshot_saved=True,
            pose_store_written=False, gallery_store_written=False, new_human_edit_created=False,
            machine_transfer_performed=False,
            mask_semantics='saved_human_fork_face_contour_pending_confirmation',
            template=original.template_metadata(t), rendering_id=original.GENERATION_NAMESPACE+':'+key,
            target_expected_revision=value['revision'], target_snapshot_payload_sha256=sha(value),
            snapshot_sha256=manifest['snapshot_sha256'], formal_manifest_sha256=manifest['formal_manifest_sha256'],
            class_assignments_sha256=manifest['classification_sha256'], metrics={},
            flags=['manual_source_not_machine_transfer', 'saved_human_mask_requires_confirmation',
                'authorized_existing_human_mask_reuse_not_new_edit'],
            manual_supplement_source=dict(schema='authorized_existing_pose_human_reuse_v1',
                diagnostic_sha256=diagnostic_sha, diagnostic_record_sha256=sha(record),
                authorization='Explicit user authorization to count these six existing saved human labels'),
            original_pose_url=original_pose_url(manual, key),
            geometry_pose_policy='original_pose_unchanged; independent_gallery_review_not_imported'))
    return result


def check_diagnostic_sources(db, records, frozen):
    frozen = indexed(frozen)
    for record in records:
        key = record['target_key']; source = frozen[key]
        history = [dict(id=i, revision=r, payload_raw=raw,
            payload_raw_sha256=hashlib.sha256(raw.encode()).hexdigest())
            for i, r, raw in db.execute('SELECT id,revision,payload FROM events WHERE target_key=? ORDER BY id', (key,))]
        if (record['current_payload_raw'] != source['current_payload_raw'] or
                record['current_payload_raw_sha256'] != source['current_payload_raw_sha256'] or
                record['human_event_id'] != source['human_event_id'] or
                record['human_polygon_revision'] != source['human_polygon_revision'] or
                record['human_event_sha256'] != source['human_event_sha256'] or
                record['source_event_history'] != history):
            raise ValueError('Supplement diagnostic raw payload/event history differs')


def assert_live_sources_unchanged(frozen):
    live = PROJECT/'outputs/pallet_pose_human_review_v1/annotations.sqlite3'
    with closing(original.readonly(live)) as db:
        for record in frozen:
            key = record['target_key']
            current = db.execute('SELECT revision,payload FROM annotations WHERE target_key=?', (key,)).fetchall()
            event = db.execute('SELECT revision,payload FROM events WHERE id=? AND target_key=?',
                (record['human_event_id'], key)).fetchall()
            if (current != [(record['current_revision'], record['current_payload_raw'])] or
                    event != [(record['human_polygon_revision'], record['human_event_payload_raw'])]):
                raise ValueError('Saved-human source changed in the live pose store')


def extend_outcomes(values, supplement_keys):
    result = copy.deepcopy(values)
    bykey = indexed(result)
    for key in supplement_keys:
        if bykey[key]['class_id'] != 10 or bykey[key]['reason'] != 'human_mask_history_protected':
            raise ValueError('Saved supplement was not an excluded human-history target')
        bykey[key]['reason'] = 'saved_human_source_added'
    return result


def updated_counts(old, manual, new, reviews, outcomes, source_counts):
    result = original.quota_counts(old, new, reviews, manual=manual)
    for cls, count in result.items():
        inherited = source_counts[str(cls)]
        count.update({k: inherited[k] for k in ('templates', 'eligible', 'compatible_targets')})
        count.update(preview=count['total'],
            outcomes=dict(Counter(v['reason'] for v in outcomes if v['class_id'] == cls)))
    return result


def copy_source_generation(source, out, hashes):
    """Retain original assets verbatim; archive superseded metadata, never its seal at root."""
    out.mkdir(parents=True)
    preserved = {}
    for path in sorted(source.rglob('*')):
        relative = str(path.relative_to(source))
        if path.is_dir():
            (out/relative).mkdir(exist_ok=True, parents=True)
            continue
        destination = out/('source_generation_evidence/'+relative if relative in REBUILT else relative)
        destination.parent.mkdir(parents=True, exist_ok=True)
        shutil.copyfile(path, destination)
        shutil.copystat(path, destination)
        if digest(destination) != hashes[relative]:
            raise ValueError('Source generation asset copy differs')
        if relative not in REBUILT:
            preserved[relative] = hashes[relative]
    return preserved


def build_report(out, combined, new_keys, manual_keys, reviews, counts):
    table = ''.join(f'<tr><td>{cls}</td><td>{c["old_total"]}</td><td>{c["manual_added"]}</td>'
        f'<td>{c["new_candidates"]}</td><td>{c["total"]}</td><td>{c["missing"]}</td></tr>' for cls, c in counts.items())
    cards = []
    for p in sorted(combined, key=lambda p: (p['class_id'], p['target_key'])):
        key = p['target_key']; manual = key in manual_keys
        if key in SUPPLEMENT_KEYS:
            label = f'【既有人工轮廓复用 r{p["target_expected_revision"]}】不是本轮新描绘，不是机器迁移'
        elif manual:
            label = f'【原24项人工描绘 r{p["target_expected_revision"]}】原位姿已保存，未确认真值'
        elif key in new_keys:
            label = '【严格原方法机器候选】待人工复核'
        elif key in reviews:
            label = f'【历史已保存图册修订 r{reviews[key]["revision"]}】原候选对照'
        else:
            label = '【历史机器候选】待人工复核'
        link = (f'<p><a href="{html.escape(p["original_pose_url"], quote=True)}">打开原位姿人工标注</a>；'
            '未导入独立图册人工保存历史，没有机器匹配评分。</p>' if manual else '')
        cards.append(f'<article data-class="{p["class_id"]}" data-batch="{"supplement" if key in SUPPLEMENT_KEYS else "previous"}" '
            f'data-kind="{"manual" if manual else "machine"}" id="target-{key}"><h2>类别 {p["class_id"]} · {label}</h2>'
            f'<img loading="lazy" src="cases/{key}.png?revision=6-saved-extension" alt="人工快照或原始候选对照">'
            f'<p>{html.escape(p["source"]["frame_id"])} ／ {p["source"]["split"]} ／ {key}</p>{link}'
            f'<a href="labelme/{key}.json">多边形（LabelMe）</a> · <a href="masks/{key}.png">掩膜</a></article>')
    page = '''<!doctype html><html lang="zh-CN"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>第六版 · 既有人工轮廓补充计数</title><style>@font-face{font-family:PreviewSans;src:url('report-font.otf?revision=6-saved-extension')}body{background:#101720;color:#e7edf5;font:16px PreviewSans,sans-serif;margin:auto;padding:20px;max-width:1500px}a{color:#77ceff}img{width:100%}article{border:1px solid #425269;margin:20px 0;padding:12px}td,th{padding:7px;border:1px solid #425269}table{border-collapse:collapse}[hidden]{display:none!important}</style>
<h1>第六版 · 既有人工轮廓补充计数（待独立核验）</h1>
<p>累计237个不同帧：历史140份保持不变，原队列24份人工描绘保持不变，本轮获授权计入6份既有原位姿人工轮廓，原67份严格方法机器草稿保持不变。本轮没有生成新机器候选，没有创建新人工编辑，也未添加研究候选。</p>
<p>已保存人工轮廓127份（图册97份、原位姿30份），历史待复核机器43份，严格方法新增机器67份。所有人工和机器新增记录均未确认为真值，不自动进入训练或机器人控制。独立图册人工保存历史未被导入。</p>
<p>类别10累计37帧，仍缺13帧；其他四类各50帧。并未完成250帧目标。保留175份原直接人工模板、全部原配准记录与门槛，不递归传播，不放宽质量条件。</p>
<table><tr><th>类别</th><th>历史总数</th><th>计入已保存人工</th><th>原严格机器候选</th><th>累计不同帧</th><th>缺额</th></tr>'''+table+'''</table>
<p><select id="filter"><option value="">全部类别</option>'''+''.join(f'<option>{c}</option>' for c in original.CLASSES)+'''</select>
<label><input type="checkbox" id="only-supplement" checked>只看本轮复用六份</label></p>'''+''.join(cards)+'''
<script>const cls=document.querySelector('#filter'),only=document.querySelector('#only-supplement');function filter(){document.querySelectorAll('article').forEach(a=>a.hidden=(!!cls.value&&a.dataset.class!==cls.value)||(only.checked&&a.dataset.batch!=='supplement'));}cls.onchange=only.onchange=filter;filter();</script></html>'''
    (out/'report_zh.html').write_text(page)
    from fontTools import subset
    from fontTools.ttLib import TTFont
    font_source = Path('/tmp/opencode/pallet_pose_design/NotoSansCJKsc-Regular.otf')
    required = {ord(c) for c in page if '\u3400' <= c <= '\u9fff'}
    with TTFont(font_source) as font:
        if not required <= set(font.getBestCmap()):
            raise ValueError('Source report font lacks Chinese characters')
        sub = subset.Subsetter(); sub.populate(text=page); sub.subset(font)
        font.save(out/'report-font.otf')
    with TTFont(out/'report-font.otf') as font:
        if not required <= set(font.getBestCmap()):
            raise ValueError('Generated report font lacks Chinese characters')
    write_json(out/'font_coverage.json', dict(chinese_glyphs=len(required), all_report_Chinese_present=True,
        font_source_sha256=digest(font_source), font_sha256=digest(out/'report-font.otf')))


def compose(output=OUTPUT, source=SOURCE, diagnostic=DIAGNOSTIC):
    source, out, diagnostic = Path(source).resolve(), Path(output).resolve(), Path(diagnostic).resolve()
    manifest, source_hashes = verified_source(source)
    if out.exists() or not out.is_relative_to(PROJECT/'outputs') or out.is_relative_to(source):
        raise ValueError('Use a fresh outputs directory outside frozen v1')
    extension_sha, diagnostic_sha = digest(__file__), digest(diagnostic)
    formal, rows, evidence = load_formal_evidence(manifest)
    before = protected_snapshot(formal)
    if before != read_json(source/'protected_formal_before.json') or before != read_json(source/'protected_formal_after.json'):
        raise ValueError('Protected formal files differ from v1')
    combined, manual, new = (read_jsonl(source/name) for name in
        ('proposals.jsonl', 'manual_proposals.jsonl', 'new_proposals.jsonl'))
    old = [p for p in combined if p['target_key'] not in set(indexed(manual)) | set(indexed(new))]
    if (len(old) != 140 or len(manual) != 24 or len(new) != 67 or
            indexed(combined) != indexed(old+manual+new) or
            len({p['source']['frame_id'] for p in combined}) != 231 or
            any(p['source'] != rows[p['target_key']] for p in combined)):
        raise ValueError('Source canonical partition/source identity differs')
    inventory = read_json(source/'template_inventory.json')
    templates = {t['row']['target_key']: t for t in inventory['templates']
        if t['rendering_id'].startswith(original.GENERATION_NAMESPACE+':')}
    if len(templates) != 175:
        raise ValueError('Expected unchanged 175 generation templates')
    records = read_jsonl(diagnostic)
    with closing(original.readonly(source/'reviews_snapshot.sqlite3', True)) as db:
        current, direct, _ = annotation_inventory(db, rows)
        direct = original.seed_union(direct, {}, manifest['snapshot_sha256'])
        if any(k not in direct or {f: v for f, v in templates[k].items() if f != 'rendering_id'} != direct[k]
                for k in SUPPLEMENT_KEYS):
            raise ValueError('Supplement is not already in the original direct human template pool')
        supplement = supplement_proposals(records, templates, current, rows, combined, manual, manifest, diagnostic_sha)
        frozen = original.freeze_manual_sources(db, supplement)
        check_diagnostic_sources(db, records, frozen)
    assert_live_sources_unchanged(frozen)
    all_manual = sorted(manual+supplement, key=lambda p: p['target_key'])
    all_proposals = sorted(combined+supplement, key=lambda p: p['target_key'])
    outcomes = extend_outcomes(read_jsonl(source/'outcomes.jsonl'), SUPPLEMENT_KEYS)
    reviews = indexed(read_jsonl(source/'refined_annotations.jsonl'))
    counts = updated_counts(old, all_manual, new, reviews, outcomes, manifest['classes'])
    if ({c: v['total'] for c, v in counts.items()} != {1: 50, 2: 50, 9: 50, 10: 37, 15: 50} or
            len(all_proposals) != 237 or len(all_manual) != 30):
        raise ValueError('Expected 237 distinct-frame entries with Class 10 missing 13')
    preserved = copy_source_generation(source, out, source_hashes)
    write_json(out/'source_generation_inventory.json', source_hashes)
    write_jsonl(out/'manual_supplement.jsonl', supplement)
    write_jsonl(out/'manual_supplement_source_records.jsonl', frozen)
    write_jsonl(out/'existing_human_reuse.jsonl', records)
    write_jsonl(out/'manual_proposals.jsonl', all_manual)
    write_jsonl(out/'manual_source_records.jsonl', sorted(read_jsonl(source/'manual_source_records.jsonl')+frozen,
        key=lambda p: p['target_key']))
    write_jsonl(out/'proposals.jsonl', all_proposals)
    write_jsonl(out/'outcomes.jsonl', outcomes)
    inventory.update(classes=counts, manual_proposals=30,
        counted_manual_source_keys=sorted(indexed(all_manual)), manual_supplement_keys=sorted(SUPPLEMENT_KEYS))
    for key in SUPPLEMENT_KEYS:
        inventory['rendering_by_target'][key] = original.GENERATION_NAMESPACE+':'+key
    write_json(out/'template_inventory.json', inventory)
    protected = read_json(source/'protected_targets.json')
    protected.update(counted_manual_source_keys=sorted(indexed(all_manual)),
        manual_supplement_keys=sorted(SUPPLEMENT_KEYS))
    write_json(out/'protected_targets.json', protected)
    snapshots = read_json(source/'snapshot_manifest.json')
    snapshots['manual_supplement'] = dict(keys=sorted(SUPPLEMENT_KEYS), count=6,
        origin=original.POSE_ORIGIN, new_human_edit_created=False,
        diagnostic_source=str(diagnostic.relative_to(PROJECT)), diagnostic_sha256=diagnostic_sha)
    write_json(out/'snapshot_manifest.json', snapshots)
    original.package_manual_preview(out, supplement, evidence)
    build_report(out, all_proposals, set(indexed(new)), set(indexed(all_manual)), reviews, counts)
    used = read_json(source/'used_image_hashes.json')
    for name, value in evidence.used.items():
        if name in used and used[name] != value:
            raise ValueError('Source image hash conflict')
        used[name] = value
    if any(digest(formal/name) != value for name, value in used.items()):
        raise ValueError('Source image changed')
    write_json(out/'used_image_hashes.json', used)
    write_json(out/'shortfalls.json', {cls: dict(missing=c['missing'], outcomes=c['outcomes'],
        explanation='Same verified original-method scan and 67 machine drafts; 24 requested saved-human masks '
            'plus six explicitly authorized existing saved-human masks. No new edits or machine/research proposals. '
            'Class 10 still needs 13 distinct frames; all other classes reach 50.') for cls, c in counts.items()})
    result = copy.deepcopy(manifest)
    result.update(state='quota_pending_independent_verification', publication_version=6,
        extension_version=VERSION, extension_code_sha256=extension_sha,
        source_generation=str(source.relative_to(PROJECT)),
        source_generation_manifest_sha256=source_hashes['manifest.json'],
        source_generation_proposals_sha256=source_hashes['proposals.jsonl'],
        source_generation_verification_sha256=source_hashes['verification.json'],
        source_generation_inventory_sha256=digest(out/'source_generation_inventory.json'),
        manual_proposals=30, manual_added=30, manual_by_class=dict(Counter(p['class_id'] for p in all_manual)),
        base_proposals=170, base_classes=original.quota_counts(old, [], reviews, manual=all_manual),
        proposals=237, classes=counts, counted_manual_source_keys=sorted(indexed(all_manual)),
        manual_supplement_keys=sorted(SUPPLEMENT_KEYS), manual_supplement_count=6,
        manual_supplement_origin=original.POSE_ORIGIN, manual_supplement_new_edits_created=0,
        manual_supplement_source=str(diagnostic.relative_to(PROJECT)), manual_supplement_source_sha256=diagnostic_sha,
        manual_supplement_sha256=digest(out/'manual_supplement.jsonl'),
        manual_supplement_source_records_sha256=digest(out/'manual_supplement_source_records.jsonl'),
        new_machine_proposals_generated_by_extension=0, research_candidates_added=0,
        outcomes=dict(Counter(v['reason'] for v in outcomes)))
    for name, field in (('proposals', 'proposals_sha256'), ('manual_proposals', 'manual_proposals_sha256'),
            ('manual_source_records', 'manual_source_records_sha256'), ('template_inventory', 'template_inventory_sha256')):
        result[field] = digest(out/(name+('.json' if name == 'template_inventory' else '.jsonl')))
    if (file_inventory(source) != source_hashes or digest(diagnostic) != diagnostic_sha or
            digest(__file__) != extension_sha or protected_snapshot(formal) != before):
        raise ValueError('Frozen generation/diagnostic/code/formal inputs changed during composition')
    assert_live_sources_unchanged(frozen)
    if any(digest(out/name) != value for name, value in preserved.items()):
        raise ValueError('Preserved source asset changed during composition')
    if any(canonical(indexed(all_proposals)[p['target_key']]) != canonical(p) for p in combined):
        raise ValueError('A canonical v1 proposal changed')
    if digest(out/'new_proposals.jsonl') != manifest['new_proposals_sha256']:
        raise ValueError('The 67 strict machine drafts changed')
    write_json(out/'preserved_source_generation_assets.json', preserved)
    write_json(out/'manifest.json', result)
    write_json(out/'generation_validation.json', dict(schema=VERSION,
        state='extension_self_checks_passed_not_independent_verification', publication_version=6,
        source_proposals_canonically_preserved=231, previous_parent_proposals=140,
        original_manual_preserved=24, supplemental_existing_human=6, all_manual=30,
        strict_machine_preserved=67, cumulative_distinct_frames=237,
        class10_total=37, class10_missing=13, templates_unchanged=175,
        production_database_writes=0, configuration_writes=0, research_candidates_added=0,
        new_human_edits_created=0, automatic_human_confirmation=False,
        automatic_training_eligible=False, robot_command_eligible=False, ground_truth_eligible=False,
        independent_verification_performed=False, published=False))
    (out/'GENERATION_HANDOFF.md').write_text(
        '# Publication 6 saved-human extension — pending independent verification\n\n'
        '237 distinct frames = unchanged parent 140 + original manual 24 + six existing saved human masks + unchanged strict machine 67. '
        'Class 10: 37, still missing 13; other four classes: 50. Not 250 and not new GT.\n\n'
        '`new_proposals.jsonl` remains the exact 67-machine sidecar. '
        '`manual_proposals.jsonl` contains 30 saved-human drafts; the six additions are in `manual_supplement.jsonl` '
        'with `manual_source_kind=authorized_existing_human_mask_reuse`, `new_human_edit_created=false`, '
        '`machine_transfer_performed=false`, empty metrics and all eligibility/confirmation flags false. '
        '`requests.jsonl` remains the original 24-item file; no requests were invented for the six.\n\n'
        '`manual_source_records.jsonl` contains all 30 frozen sources, with the six separately in '
        '`manual_supplement_source_records.jsonl`. Human-event SHA-256 hashes exact original UTF-8 payload bytes. '
        '`existing_human_reuse.jsonl` preserves the diagnostic source and full per-target event histories.\n\n'
        'The original generator `code_sha256` and all original algorithm hashes are unchanged. '
        '`extension_code_sha256` separately binds the composer. `source_generation` points to v1 and binds its '
        'passed verification, manifest and proposals. Superseded metadata and the v1 seal are preserved only under '
        '`source_generation_evidence/`, not as a v2 verification. All historical assets, namespaces, snapshots, '
        'accepted candidates and registration attempts are byte-identical. The 175 templates are unchanged; only six '
        'own-key `quota_generation:` rendering mappings were added.\n\n'
        'Only six outcomes change: `human_mask_history_protected` becomes `saved_human_source_added`. '
        'No generation/selection was rerun. Independent verification must retain the source scan/selection '
        'proof and verify these six explicit existing-human quota additions separately. '
        'No multiscale research candidates were added. Zero live DB/config/service writes. '
        'Independent gallery history is not imported; manual detail initializes from the proposal polygon with '
        'no saved gallery overlay until a real gallery edit.\n')
    write_json(out/'artifact_hashes.json', {str(p.relative_to(out)): digest(p)
        for p in sorted(out.rglob('*')) if p.is_file() and p != out/'artifact_hashes.json'})
    return result


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--output', type=Path, default=OUTPUT)
    parser.add_argument('--source', type=Path, default=SOURCE)
    parser.add_argument('--diagnostic', type=Path, default=DIAGNOSTIC)
    args = parser.parse_args()
    result = compose(args.output, args.source, args.diagnostic)
    print(json.dumps(dict(state=result['state'], publication_version=6, proposals=result['proposals'],
        manual=result['manual_proposals'], machine=result['new_proposals'],
        class10=result['classes'][10]['total'], missing=result['classes'][10]['missing'])), flush=True)


if __name__ == '__main__':
    main()
