"""Fresh protected remaining-image worklist; only the actually updated M2 predicts."""
from collections import Counter,defaultdict
from contextlib import closing
import hashlib
import json
import math
from pathlib import Path
import shutil
import sqlite3
import time

import cv2
import numpy as np
from PIL import Image,ImageDraw,ImageFont

from .cluster_targets import digest,protected_snapshot
from .mask_annotation_update_data import ROOT as TRAINING,context
from .mask_model_training_data import PROJECT,read,jsonl,write,sha,require,letterbox,gpu_receipt
from .mask_model_worklist import FLAGS,polygonize
from .mask_class_keypoints import convert,VERSION as CONVERSION_VERSION,SETTINGS
from .mask_remaining_classes import confirmed,original_rectangle
from .mask_template_refined import QUARANTINE,readonly
from .mask_quality_recovery import POSE,GALLERY,fingerprint
from .mask_quota_saved_extension import file_inventory,load_formal_evidence
from .pose_review_geometry import raster_mask

ROOT=PROJECT/'outputs/pallet_mask_annotation_update_requests_v1'
SCHEMA='updated1896_M2_class_standard_keypoint_preannotation_v1'
NAMESPACE='model-annotation-update-remaining-v1'
DRAFT_PREFIX='mask-annotation-update-remaining-v1:'


def raw_sha(raw):return hashlib.sha256(raw.encode('utf-8')).hexdigest() if raw else None


def stage():
    from scripts.verify_mask_under50_requests import native_quality
    require(not ROOT.exists(),'Never overwrite a remaining-image worklist')
    manifest=read(TRAINING/'dataset_manifest.json');records=jsonl(TRAINING/'private/training_records.jsonl')
    formal,rows,evidence=load_formal_evidence(read(PROJECT/'outputs/pallet_mask_remaining_round5_v1/manifest.json'))
    require(len(records)==1896 and manifest['records']==1896,'Completed337 training snapshot required')
    counts=Counter(r['class_id'] for r in records);gaps={c:max(0,100-counts[c]) for c in range(1,23)}
    protected=set(QUARANTINE)|{r['target_key'] for r in records}
    protected.update(r['target_key'] for r in jsonl(PROJECT/'outputs/pallet_mask_remaining_round5_v1/proposals.jsonl'))
    with closing(readonly(POSE)) as db:
        current=dict(db.execute('SELECT target_key,payload FROM annotations'));history=defaultdict(list)
        for key,raw in db.execute('SELECT target_key,payload FROM events ORDER BY id'):history[key].append(json.loads(raw))
    for key in set(current)|set(history):
        values=history[key]+([json.loads(current[key])] if key in current else [])
        if key not in current or any(v.get('state') in ('deleted','deferred','confirmed') or confirmed(v) or not original_rectangle(v.get('polygon'),rows[key]) for v in values):protected.add(key)
    inventories={}
    for pattern in ('requests.jsonl','shortlist.jsonl','inspection_targets.jsonl'):
        for path in sorted((PROJECT/'outputs').rglob(pattern)):
            if path.is_relative_to(ROOT):continue
            for r in jsonl(path):
                if r.get('target_key') in rows:protected.add(r['target_key'])
            inventories[str(path.relative_to(PROJECT))]=digest(path)
    # Every real review namespace/current/history is protected even if its
    # publication used a nonstandard filename; no deleted record is resurrected.
    for database in sorted((PROJECT/'outputs').glob('pallet_mask*_reviews_v*/mask_reviews.sqlite3')):
        with closing(readonly(database)) as db:
            for table in ('reviews','events'):
                protected.update(k for k, in db.execute(f'SELECT DISTINCT target_key FROM {table}') if k in rows)
    protected_frames={rows[k]['frame_id'] for k in protected}
    protected_hashes={digest(formal/name) for name in {rows[k]['image'] for k in protected}}
    available={};reasons=Counter()
    for key,row in sorted(rows.items()):
        if not gaps[row['final_class_id']]:continue
        if key in protected or row['frame_id'] in protected_frames:reasons['prior_protected_key_or_frame']+=1;continue
        try:quality=native_quality(row,evidence)
        except ValueError as error:reasons[str(error)]+=1;continue
        h=digest(formal/row['image'])
        if h in protected_hashes:reasons['prior_protected_pixel_bytes']+=1;continue
        available[key]=(quality,h)
    # Capacity is a per-class count of distinct frames/hashes before shared-image
    # cross-class assignments, not a fictitious sum of simultaneously available images.
    capacity={}
    for cls in range(1,23):
        fs=set();hs=set()
        for key,(_,h) in sorted(available.items()):
            r=rows[key]
            if r['final_class_id']==cls and r['frame_id'] not in fs and h not in hs:fs.add(r['frame_id']);hs.add(h)
        capacity[cls]=len(fs)
    order=sorted((c for c in range(1,23) if gaps[c]),key=lambda c:(capacity[c],c))
    selected=[];frames=set(protected_frames);hashes=set(protected_hashes);groups=Counter();policies=Counter()
    for cls in order:
        budget=4*gaps[cls]+16
        for _ in range(budget):
            options=[k for k,(_,h) in available.items() if rows[k]['final_class_id']==cls and rows[k]['frame_id'] not in frames and h not in hashes]
            if not options:break
            key=min(options,key=lambda k:(groups[cls,rows[k]['group_id']],policies[cls,rows[k]['policy_id']],
                -available[k][0]['bbox_height_native_pixels'],-available[k][0]['clarity_score'],k))
            row=rows[key];frames.add(row['frame_id']);hashes.add(available[key][1]);groups[cls,row['group_id']]+=1;policies[cls,row['policy_id']]+=1
            selected.append(dict(target_key=key,class_id=cls,source=row,request_order=len(selected)+1,native_quality=available[key][0],image_sha256=available[key][1],
                pose_payload_raw_sha256=raw_sha(current.get(key)),gallery_payload_raw_sha256=None))
    ROOT.mkdir(mode=0o700);(ROOT/'private').mkdir(mode=0o700)
    write(ROOT/'private/shortlist.jsonl',selected,lines=True);shutil.copyfile(TRAINING/'class_keypoint_standard.json',ROOT/'class_keypoint_standard.json')
    review_paths={str(p.relative_to(PROJECT)):fingerprint(p) for p in sorted((PROJECT/'outputs').glob('pallet_mask*_reviews_v*/mask_reviews.sqlite3'))}
    write(ROOT/'input_manifest.json',dict(schema='remaining_after_completed337_staging_v1',real_saved_before=dict(counts),remaining_to100=gaps,
        actual_manual_total=1896,native_capacity_per_class_before_crossclass_assignment=capacity,
        allocation_policy='scarcest eligible class first; group/policy-balanced, no target manual labels',
        original_frame_shortlist_and_rejected_sources_not_reopened=True,
        previously_protected_targets=len(protected),prior_worklist_inventories_sha256=inventories,
        existing_review_store_fingerprints=review_paths,pose_fingerprint=fingerprint(POSE),gallery_fingerprint=fingerprint(GALLERY),
        configuration_sha256=file_inventory(PROJECT/'configs'),formal_protected=protected_snapshot(formal),
        formal_manifest_sha256=read(PROJECT/'outputs/pallet_mask_remaining_round5_v1/manifest.json')['formal_manifest_sha256'],
        training_dataset_manifest_sha256=digest(TRAINING/'dataset_manifest.json'),primary_model='m2 updated final EMA only after completed checkpoint verified',
        class_standard_sha256=digest(ROOT/'class_keypoint_standard.json'),shortlist_sha256=digest(ROOT/'private/shortlist.jsonl'),
        staged_counts=dict(Counter(r['class_id'] for r in selected)),skip_reasons=dict(reasons),conversion_version=CONVERSION_VERSION,conversion_settings=SETTINGS))
    print(json.dumps(dict(state='staged_fresh_unprocessed_new_images_training_completion_still_required',count=len(selected),
        remaining=gaps,per_class_capacity=capacity,staged_counts=dict(Counter(r['class_id'] for r in selected)))),flush=True)


def infer(attempt=None):
    import torch
    from rfdetr import RFDETRSegSmall
    from .mask_annotation_full_train import normalize
    from .mask_model_improvement import predicted_rle
    from .mask_model_improvement_adapter import mask_logits,native_logits,highest_class_query
    require(not (ROOT/'private/predictions.jsonl').exists(),'Never overwrite previous inference or failure evidence')
    training=read(TRAINING/'TRAINING_HANDOFF.json')
    require(training['state']=='verified_both_completed337_warm_updates_all1896_not_quality_release' and training['errors']==[],'Both real training updates must finish before remaining-image inference')
    inputs=read(ROOT/'input_manifest.json');require(inputs['training_dataset_manifest_sha256']==training['dataset_manifest_sha256'],'Inference/model data version differs')
    checkpoint=TRAINING/'m2/final_ema.pt';h=digest(checkpoint);require(h==training['runs']['m2']['checkpoint_sha256'],'Updated model pin differs')
    gpu=gpu_receipt('m2');torch.set_num_threads(4);cv2.setNumThreads(1)
    weights=torch.load(checkpoint,map_location='cpu',weights_only=True)
    generic=PROJECT/'outputs/pallet_mask_model_training_v1/generic_pretraining/rf-detr-seg-small.pt'
    wrapper=RFDETRSegSmall(num_classes=1,resolution=576,device='cuda:0',pretrain_weights=str(generic),gradient_checkpointing=True,compile=False)
    model=wrapper.model.model;model.load_state_dict(weights['model'],strict=True);model.cuda().eval();del weights
    formal,_,evidence=load_formal_evidence(read(PROJECT/'outputs/pallet_mask_remaining_round5_v1/manifest.json'))
    standard=read(ROOT/'class_keypoint_standard.json');predictions=[];started=time.monotonic()
    start_path=ROOT/'private/inference_start.json'
    if attempt is not None:
        require(isinstance(attempt,str) and attempt.isdigit() and len(attempt)==3,'Explicit three-digit attempt ID required')
        attempt_directory=ROOT/'private/inference_attempts'/attempt;attempt_directory.mkdir(parents=True)
        start_path=attempt_directory/'start.json'
    write(start_path,dict(checkpoint_sha256=h,training_handoff_sha256=digest(TRAINING/'TRAINING_HANDOFF.json'),
        model_route='m2',gpu=gpu,input='image_pixels_only_in_original_bbox_fixed_context',threshold=.5,query='highest_classification_only_no_GT',
        class_standard_used_only_after_network_forward=True))
    with torch.inference_mode():
        for index,r in enumerate(jsonl(ROOT/'private/shortlist.jsonl')):
            row=r['source'];roi=context(row['bbox'],row['size']);x1,y1,x2,y2=roi
            grey=evidence.image(row['frame_id'])[y1:y2,x1:x2];canvas,_,_,transform=letterbox(grey,None,(576,576))
            outputs=model(normalize(canvas)[None].cuda());query,confidence=highest_class_query(outputs)
            mask=native_logits(mask_logits(outputs)[0,query],transform).sigmoid().cpu().numpy()>=.5
            b=row['bbox'];area=int(mask.sum());ratio=area/(b['width']*b['height']);reason=None
            if mask[0].any() or mask[-1].any() or mask[:,0].any() or mask[:,-1].any():reason='model_mask_touches_context_edge'
            l=max(0,math.floor(b['x']-x1));t=max(0,math.floor(b['y']-y1));rr=min(mask.shape[1],math.ceil(b['x']+b['width']-x1));bt=min(mask.shape[0],math.ceil(b['y']+b['height']-y1))
            overlap=float(mask[t:bt,l:rr].sum()/max(1,area))
            if not .05<=ratio<=1.25:reason=reason or 'implausible_mask_area_for_original_bbox'
            if overlap<.75:reason=reason or 'model_mask_not_localized_to_requested_target'
            dense,dense_info=polygonize(mask) if reason is None else (None,dict(reason=reason))
            k=standard['classes'][str(r['class_id'])]['standard_count']
            if dense:p,info=convert(mask,dense,k,b['height'],origin=(x1,y1),native_size=row['size'])
            else:p,info=None,dict(reason=dense_info['reason'])
            predictions.append(dict(target_key=r['target_key'],class_id=r['class_id'],roi=roi,raw_native_prediction_rle=predicted_rle(mask),
                raw_dense_polygon_local=dense,raw_polygonization=dense_info,polygon=p,conversion=info,standard_count=k,
                selected_query=query,class_confidence_not_quality_probability=confidence,raw_mask_area=area,
                mask_bbox_area_ratio=ratio,mask_fraction_inside_original_bbox=overlap,checkpoint_sha256=h,threshold=.5))
            if (index+1)%100==0:print('Updated M2 inferred',index+1,'fresh remaining images',flush=True)
    write(ROOT/'private/predictions.jsonl',predictions,lines=True)
    write(ROOT/'private/inference_complete.json',dict(state='actual_updated_M2_inference_class_K_conversion_completed_not_quality_pass',
        targets=len(predictions),keypoint_candidates=sum(bool(r['polygon']) for r in predictions),
        by_class=dict(Counter(r['class_id'] for r in predictions if r['polygon'])),
        rejections=dict(Counter(r['conversion']['reason'] for r in predictions if not r['polygon'])),
        checkpoint_sha256=h,seconds=time.monotonic()-started,gpu=gpu))
    print(read(ROOT/'private/inference_complete.json'),flush=True)


def contacts():
    out=ROOT/'private/contact_sheets';out.mkdir();records={r['target_key']:r for r in jsonl(ROOT/'private/shortlist.jsonl')}
    formal=Path(read(PROJECT/'configs/active_formal_dataset.json')['dataset']);predictions=jsonl(ROOT/'private/predictions.jsonl')
    pages=[];font=ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf',13)
    for cls in range(1,23):
        candidates=[r for r in predictions if r['class_id']==cls and r['polygon']]
        for start in range(0,len(candidates),24):
            chunk=candidates[start:start+24];sheet=Image.new('RGB',(1760,math.ceil(len(chunk)/4)*155),'#111a24');draw=ImageDraw.Draw(sheet)
            for i,r in enumerate(chunk):
                key=r['target_key'];row=records[key]['source'];b=row['bbox'];l=max(0,math.floor(b['x']-8));t=max(0,math.floor(b['y']-12))
                rr=min(row['size'][0],math.ceil(b['x']+b['width']+8));bt=min(row['size'][1],math.ceil(b['y']+b['height']+12))
                raw=Image.open(formal/row['image']).convert('RGB').crop((l,t,rr,bt));overlay=raw.copy();d=ImageDraw.Draw(overlay)
                points=[(x-l,y-t) for x,y in r['polygon']];d.line(points+[points[0]],fill='#55d5ff',width=1)
                for x,y in points:d.ellipse((x-1,y-1,x+1,y+1),fill='#ffbe43')
                scale=min(216/raw.width,112/raw.height);size=(max(1,round(raw.width*scale)),max(1,round(raw.height*scale)));x=(i%4)*440;y=(i//4)*155
                for j,image in enumerate((raw,overlay)):sheet.paste(image.resize(size,Image.Resampling.NEAREST),(x+j*220,y+24))
                draw.text((x+3,y+2),f'C{cls} #{start+i+1} {key[:10]} K{len(points)}',font=font,fill='white')
                draw.text((x+3,y+136),'RAW                  UPDATED M2 CLASS-K (not GT)',font=font,fill='#c5e1f4')
            name=f'C{cls:02d}_{start//24+1:02d}.png';sheet.save(out/name)
            pages.append(dict(path=str((out/name).relative_to(PROJECT)),sha256=digest(out/name),class_id=cls,
                target_keys=[r['target_key'] for r in chunk],candidate_indices=list(range(start+1,start+len(chunk)+1))))
    write(out/'inventory.json',dict(predictions_sha256=digest(ROOT/'private/predictions.jsonl'),pages=pages,scope='AI coarse paired image/model draft inspection only'))
    print('Contact sheets generated',len(pages),flush=True)


def build():
    from .mask_annotation_update_review import editor_js,validate
    from scripts.build_mask_remaining_direct_requests import build_font
    from .mask_gallery import ASSETS
    require(not (ROOT/'manifest.json').exists(),'Never overwrite a verified/published remaining-image version')
    inputs=read(ROOT/'input_manifest.json');standard=read(ROOT/'class_keypoint_standard.json');standard_sha=digest(ROOT/'class_keypoint_standard.json')
    inference=read(ROOT/'private/inference_complete.json');checkpoint_sha=inference['checkpoint_sha256']
    decisions=read(ROOT/'private/visual_decisions.json');predictions=jsonl(ROOT/'private/predictions.jsonl')
    require(decisions['predictions_sha256']==digest(ROOT/'private/predictions.jsonl'),'Coarse review inputs differ')
    records={r['target_key']:r for r in jsonl(ROOT/'private/shortlist.jsonl')};counts=Counter();selected=[];withheld=[]
    for p in predictions:
        key=p['target_key'];cls=p['class_id'];r=records[key];decision=decisions['decisions'].get(key,{})
        if not p['polygon'] or not decision.get('publish') or counts[cls]>=inputs['remaining_to100'][str(cls)]:
            withheld.append(dict(target_key=key,class_id=cls,reason=p['conversion']['reason'] or decision.get('reason','quota_or_coarse_visual_withheld')));continue
        proof=dict(model_family='RF-DETR-Seg Small',training_version=str(TRAINING.relative_to(PROJECT)),checkpoint='m2/final_ema.pt',
            checkpoint_sha256=checkpoint_sha,training_dataset_manifest_sha256=inputs['training_dataset_manifest_sha256'],
            training_handoff_sha256=digest(TRAINING/'TRAINING_HANDOFF.json'),predictions_sha256=digest(ROOT/'private/predictions.jsonl'),
            native_mask_rle_sha256=sha(p['raw_native_prediction_rle']),threshold=.5,query_selected_by='classification_only_no_target_GT',
            corner_conversion=p['conversion'],visual_inspection=decision,human_saved=False,assistant_redrawn=False,quality_gate_passed=False)
        proposal=dict(schema=SCHEMA,origin='updated_M2_prediction',status='model_preannotated_pending_human_review',
            target_key=key,class_id=cls,source=r['source'],polygon=p['polygon'],vertex_count=len(p['polygon']),
            formal_manifest_sha256=inputs['formal_manifest_sha256'],model_source_image_sha256=r['image_sha256'],
            pose_payload_raw_sha256=r['pose_payload_raw_sha256'],gallery_payload_raw_sha256=None,
            class_keypoint_constraint=dict(class_id=cls,standard_count=standard['classes'][str(cls)]['standard_count'],standard_sha256=standard_sha,
                method='unique_class_saved_polygon_vertex_count_mode',physical_semantic_slots_confirmed=False,ordered_clockwise=True),
            model_provenance=proof,mask_semantics='updated_mask_class_K_visible_fork_face_draft_requires_human_review_not_GT',**dict.fromkeys(FLAGS,False))
        validate(proposal,standard,standard_sha,checkpoint_sha);selected.append(proposal);counts[cls]+=1
    require(selected,'No reliable new drafts: preserve failures, do not manufacture a publication')
    formal=Path(read(PROJECT/'configs/active_formal_dataset.json')['dataset'])
    for folder in ('images','cases','masks','labelme'):(ROOT/folder).mkdir()
    for p in selected:
        key=p['target_key'];row=p['source'];polygon=p['polygon'];k=len(polygon)
        shutil.copyfile(formal/row['image'],ROOT/'images'/f'{key}.png');image=Image.open(ROOT/'images'/f'{key}.png').convert('RGB')
        draw=ImageDraw.Draw(image);points=[tuple(v) for v in polygon];draw.line(points+[points[0]],fill='#55d5ff',width=1)
        b=row['bbox'];l=max(0,math.floor(b['x']-12));t=max(0,math.floor(b['y']-16));rr=min(row['size'][0],math.ceil(b['x']+b['width']+12));bt=min(row['size'][1],math.ceil(b['y']+b['height']+16))
        crop=image.crop((l,t,rr,bt)).resize(((rr-l)*3,(bt-t)*3),Image.Resampling.NEAREST);d=ImageDraw.Draw(crop)
        for i,(x,y) in enumerate(polygon,1):
            xx=(x-l)*3;yy=(y-t)*3;d.ellipse((xx-2,yy-2,xx+2,yy+2),fill='#ffbe43');d.text((xx+3,yy-9),str(i),fill='white',stroke_width=1,stroke_fill='black')
        crop.save(ROOT/'cases'/f'{key}.png');Image.fromarray(raster_mask(polygon,*row['size']).astype(np.uint8)*255).save(ROOT/'masks'/f'{key}.png')
        flags=dict(model_preannotation=True,human_confirmed=False,ground_truth_eligible=False)
        shapes=[dict(label='pallet',shape_type='polygon',points=polygon,group_id=row['box_index'],flags=flags)]
        shapes.extend(dict(label=f'kp_{i:02d}',shape_type='point',points=[point],group_id=row['box_index'],flags=flags) for i,point in enumerate(polygon,1))
        write(ROOT/'labelme'/f'{key}.json',dict(version='5.0.0',imagePath=f'../images/{key}.png',imageData=None,imageWidth=row['size'][0],imageHeight=row['size'][1],
            flags=flags,shapes=shapes,keypoints_xy=polygon,num_keypoints=k,class_id=p['class_id'],class_keypoint_constraint=p['class_keypoint_constraint'],
            keypoint_order_semantics='clockwise geometric slots, physical semantic correspondence not confirmed',
            model_checkpoint_sha256=checkpoint_sha,annotation_scope='single_target_pending_human_review_not_GT'))
    write(ROOT/'proposals.jsonl',selected,lines=True)
    write(ROOT/'requests.jsonl',[dict(target_key=p['target_key'],class_id=p['class_id'],keypoint_count=p['vertex_count'],status='updated_model_machine_draft_pending_real_human_review') for p in selected],lines=True)
    write(ROOT/'private/withheld.json',withheld)
    page='<!doctype html><html lang="zh-CN"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>337已复核后 · 更新M2剩余新图关键点复核</title><style>@font-face{font-family:Review;src:url("report-font.otf")}*{box-sizing:border-box}body{font:16px/1.6 Review,sans-serif;background:#101720;color:#e7edf5;max-width:1100px;margin:auto;padding:12px}article{border:1px solid #536479;padding:12px;margin:18px 0}p,h2,td{overflow-wrap:anywhere}img{display:block;max-width:100%;height:auto}a{color:#80ceff}table{width:100%;border-collapse:collapse}td,th{padding:5px;border:1px solid #536479}@media(max-width:480px){h1{font-size:23px}body{padding:8px}}</style>'
    page+=f'<h1>更新M2 · 剩余新图关键点预标注</h1><p>前337张均已真实保存，381条事件按最新修订冻结后，1896张人工图像、240个分量全部参与新版本训练。使用更新后M2最终EMA生成本批{len(selected)}张不同新图；不是旧预测重贴标签，不重开历史保护图。</p><p>初始点数沿用22类已确定标准；人工微调可点击边增点、拖点、删选中点，支持撤销/重做。保存失败不跳转、不清除本机草稿。人工实际点数单独留痕，不改类别标准。</p><p>机器草稿未保存不计完成，不自动成为GT、训练数据、传播种子或机器人指令。只有训练拟合诊断，没有独立准确率证明。无法保持结构并满足标准点数者暂缓；缺口不靠旧图或假角点凑数。沿用原访问码，旧入口、原始框/图像/PCD和人工历史不变。</p><p>筛选 <select id="request-filter"><option value="">全部</option>'+''.join(f'<option value="{c}">Class {c} · {standard["classes"][str(c)]["standard_count"]}点</option>' for c in range(1,23))+'</select></p><table><tr><th>类别</th><th>初始标准点数</th><th>已保存人工</th><th>本批草稿</th><th>全保存后仍缺</th></tr>'
    for c in range(1,23):
        saved=inputs['real_saved_before'][str(c)];gap=inputs['remaining_to100'][str(c)]
        page+=f'<tr><td>Class {c}</td><td>{standard["classes"][str(c)]["standard_count"]}</td><td>{saved}</td><td>{counts[c]}</td><td>{max(0,gap-counts[c])}</td></tr>'
    page+='</table>'
    for p in selected:
        key=p['target_key'];page+=f'<article id="target-{key}" data-class="{p["class_id"]}"><h2>Class {p["class_id"]} · 初始标准{p["vertex_count"]}点 · 待人工复核</h2><img loading="lazy" src="cases/{key}.png" alt="更新M2生成的新图关键点草稿"><p>核对梁缘、脚底、凹口和观察面；人工可增点，初始点数一致不代表角点位置准确。</p><a href="images/{key}.png">原图</a> · <a href="labelme/{key}.json">关键点LabelMe</a> · <a href="masks/{key}.png">草稿掩膜</a></article>'
    page+='<script>const f=document.getElementById("request-filter");f.onchange=()=>document.querySelectorAll("article").forEach(a=>a.hidden=!!f.value&&a.dataset.class!==f.value);</script></html>'
    (ROOT/'report_zh.html').write_text(page);js=editor_js();(ROOT/'model-editor.js').write_text(js)
    build_font(ROOT,page+js+(ASSETS/'editor.html').read_text())
    assets={n:digest(ROOT/n) for n in ('report_zh.html','report-font.otf','FONT_LICENSE.txt','model-editor.js')}
    for p in selected:
        for folder,ext in [('images','png'),('cases','png'),('masks','png'),('labelme','json')]:
            n=f'{folder}/{p["target_key"]}.{ext}';assets[n]=digest(ROOT/n)
    write(ROOT/'manifest.json',dict(schema='completed337_updated_M2_remaining_keypoint_worklist_v1',source_namespace=NAMESPACE,
        request_count=len(selected),class_counts=dict(counts),actual_human_saved_before=inputs['real_saved_before'],base_manual_count=1896,target_per_class=100,
        filter_classes=list(range(1,23)),checkpoint_sha256=checkpoint_sha,training_dataset_manifest_sha256=inputs['training_dataset_manifest_sha256'],
        training_handoff_sha256=digest(TRAINING/'TRAINING_HANDOFF.json'),class_standard_sha256=standard_sha,
        standard_counts={c:s['standard_count'] for c,s in standard['classes'].items()},input_manifest_sha256=digest(ROOT/'input_manifest.json'),
        proposals_sha256=digest(ROOT/'proposals.jsonl'),requests_sha256=digest(ROOT/'requests.jsonl'),predictions_sha256=digest(ROOT/'private/predictions.jsonl'),
        visual_decisions_sha256=digest(ROOT/'private/visual_decisions.json'),public_assets=assets,source_fingerprints=inputs['existing_review_store_fingerprints'],
        conditional_gap_after_all_drafts_saved={str(c):max(0,inputs['remaining_to100'][str(c)]-counts[c]) for c in range(1,23)},
        qualified_labels_created=0,agent_human_events_created=0,model_production_activated=False,quality_not_certified=True))
    print(json.dumps(dict(state='built_updated_M2_fresh_classK_drafts_pending_independent_verification',count=len(selected),class_counts=dict(counts),
        conditional_remaining=sum(max(0,inputs['remaining_to100'][str(c)]-counts[c]) for c in range(1,23)))),flush=True)
