"""v217: source-grounded local-model code edits, approved only on §E feature branches. No automatic merge, deployment, code execution, or hidden OAuth permissions. """ from __future__ import annotations import ast import difflib import hashlib import json import re from fastapi import HTTPException import forge_project_tools_v213 as engine import engine_starter_pack_v215 as packs import github_workflows_v212 as approvals ROOT=engine.ROOT + "/" COMMAND=re.compile(r"^@github\s+engine\s+code\s+(?:help|inspect|context|verify|plan|propose|task)(?:\s|$)", re.I) TASK=re.compile(r"^engine code task (.{8,300}) on ((?:feature|fix|chore)/\S+)$",re.I|re.S) PROPOSE=re.compile(r"^engine code propose ([^\s]+) on (\S+) :: (.{8,300})$", re.I|re.S) INSPECT=re.compile(r"^engine code inspect (\S+)$", re.I) CONTEXT=re.compile(r"^engine code context (\S+) :: (.{5,300})$", re.I|re.S) VERIFY=re.compile(r"^engine code verify ((?:feature|fix|chore)/\S+)$", re.I) PLAN=re.compile(r"^engine code plan (.{8,300})$", re.I|re.S) SHA=re.compile(r"^[0-9a-f]{40}$") NAME=re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,100}$") def is_command(prompt): return bool(COMMAND.match(str(prompt or "").strip())) def is_coding_intent(prompt): """Recognize an explicit engine-coding task, without authorizing changes.""" q=str(prompt or "").strip() if len(q)<16 or len(q)>850 or q.lower().startswith("@github confirm "): return False q=re.sub(r"^@github\s+(?:ask|explore|analyze)\s+","",q,flags=re.I) actionable=re.match( r"^(?:(?:please\s+)?|(?:can|could|would|will)\s+you\s+(?:please\s+)?|" r"(?:i\s+want\s+you\s+to|i(?:'d|\s+would)\s+like\s+you\s+to)\s+)" r"(?:build|implement|fix|add|create|develop|repair|update|upgrade|" r"extend|improve|modify|make)\b",q,re.I) return bool(actionable and re.search( r"(?:§e\b|§wyrl[§z]\s+engine|our\s+(?:game\s+)?(?:engine|editor)|" r"game\s+engine|starter\s+packs?|native\s+editor|sheep\s+tag|" r"anime\s+studio|forge\s+editor)",q,re.I)) def _natural_mission(gh,rec,repo,prompt): """Read real main manifest/tree to guide an approved coding workflow.""" engine._access(gh,rec,repo,"read") goal=re.sub(r"^@github\s+(?:ask|explore|analyze)\s+","",prompt,flags=re.I).strip() report=engine._plan(gh,rec,repo,goal[:260]) head=approvals._branch_sha(gh,rec["token"],repo,"main") candidates=_candidate_paths(gh,rec,repo,head,goal) lines=[ "## §E coding mission — source inspected, NOTHING CHANGED", "Goal: "+goal[:400], "Verified main commit: "+head, "", "### Source architecture and initial plan", report, "", "### Relevant existing source candidates (not automatically modified)", *("- "+p for p in candidates[:10]), ] if not candidates: lines.append("No sufficiently relevant existing runtime source found. A new component may be needed; the current bounded source-edit tool cannot create arbitrary runtime modules.") lines.extend([ "", "### Authorized continuation", "1. Request @GitHub create branch feature/engine-review from main, then approve the branch proposal.", "2. Once that branch exists, request @GitHub engine code task "+goal[:240]+" on feature/engine-review to have the local coding model inspect source and prepare a reviewable edit.", "3. Use @GitHub engine code verify feature/engine-review to see GitHub CI evidence, then @GitHub engine review feature/engine-review for a draft PR and the separate engine build/release gates.", "For scene-based starters derived from existing modes use @GitHub engine starters and the approved @GitHub engine pack flow. A copied scene is not a newly coded game mode.", "No branch, source edit, starter, PR, or deployment was created by this plan." ]) return "\n".join(lines) def _path(value): path=str(value or "") if (not path.startswith(ROOT) or len(path)>185 or "%" in path or "\\" in path or any(v in ("", ".", "..") for v in path.split("/"))): raise HTTPException(422,"Unsafe engine file path") local=path[len(ROOT):] if local=="build_space.py": return path parts=local.split("/") if (len(parts)!=2 or parts[0] not in ("runtime","patches","tests") or not NAME.fullmatch(parts[1]) or not parts[1].endswith({"runtime":(".js",".css"),"patches":(".py",),"tests":(".mjs",)}[parts[0]])): raise HTTPException(422,"Only existing engine runtime, patch, test files and build_space.py can be edited") return path def _paths(raw): result=[_path(p.strip()) for p in str(raw or "").split(",")] if len(result) not in (1,2) or len(set(result))!=len(result): raise HTTPException(422,"Select one or two unique source paths") return result def _source(gh,rec,repo,path,ref): doc=gh._text(rec["token"],repo,path,ref,max_bytes=95000) if (not isinstance(doc,dict) or not SHA.fullmatch(str(doc.get("sha") or "")) or not isinstance(doc.get("body"),str) or len(doc["body"].encode())>95000): raise HTTPException(409,"Required engine source/blob could not be verified") return doc def _authority(gh,rec,repo,branch): engine._access(gh,rec,repo,"branch-write") branch,head=engine._branch_head(gh,rec,repo,branch) main=approvals._branch_sha(gh,rec["token"],repo,"main") manifest,data=engine._manifest(gh,rec,repo) if not SHA.fullmatch(str(manifest.get("sha") or "")) or len(data["patches"])<50: raise HTTPException(409,"Engine manifest unverified") return branch,head,main,manifest["sha"] def _validate(path,body): if "\x00" in body or len(body.encode())>95000: raise HTTPException(422,"Invalid or oversized model source") if path.endswith(".py"): try: tree=ast.parse(body,filename=path) except SyntaxError as exc: raise HTTPException(422,"Generated Python syntax invalid") from exc func="main" if path.endswith("build_space.py") else "apply" if not any(isinstance(n,(ast.FunctionDef,ast.AsyncFunctionDef)) and n.name==func for n in tree.body): raise HTTPException(422,"Required engine Python entrypoint lost: "+func) # JavaScript and CSS need separate Node/browser CI, not an invented model pass. def _parse(raw,paths,bodies): if len(raw)>7500 or not raw.startswith("{") or not raw.endswith("}"): return None try: data=json.loads(raw) except ValueError: return None if not isinstance(data,dict) or set(data)!={"edits"} or not isinstance(data["edits"],list) or len(data["edits"])!=len(paths): return None edits={} for row in data["edits"]: if not isinstance(row,dict) or set(row)!={"path","old","new"}: return None path,old,new=row["path"],row["old"],row["new"] if (not isinstance(path,str) or path not in paths or path in edits or not isinstance(old,str) or not isinstance(new,str) or not 8<=len(old)<=1500 or not 1<=len(new)<=3000 or old==new or bodies[path].count(old)!=1): return None updated=bodies[path].replace(old,new,1) _validate(path,updated) edits[path]={"old":old,"new":new,"resultHash":hashlib.sha256(updated.encode()).hexdigest()} return edits if set(edits)==set(paths) else None def _candidate_paths(gh, rec, repo, sha, goal): """Find real current editor code paths; model cannot invent a path.""" tree=engine._github(gh,rec,repo,"/git/trees/"+sha+"?recursive=1") if not isinstance(tree,dict) or tree.get("truncated") or not isinstance(tree.get("tree"),list): raise HTTPException(409,"GitHub engine source tree incomplete; no automatic path selection") matches=[] words=[w for w in re.findall(r"[a-z0-9]{4,}",goal.lower()) if w not in ("please","could","would","about","build","create","make","with","that","from","engine","editor")] for item in tree["tree"]: if not isinstance(item,dict) or item.get("type")!="blob": continue path=str(item.get("path") or "") try:_path(path) except HTTPException:continue size=item.get("size") if not isinstance(size,int) or size>85000 or size<10:continue base=path.split("/")[-1].lower() score=sum(4 for term in words if term in base) if "scene" in goal.lower() and ("scene" in base or "stage" in base): score+=3 if "timeline" in goal.lower() and "timeline" in base: score+=6 if "sheep" in goal.lower() and "sheep" in base: score+=6 if "anime" in goal.lower() and "anime" in base: score+=5 if "build" in goal.lower() and path.endswith("build_space.py"): score+=3 matches.append((score,path)) matches.sort(key=lambda x:(-x[0],x[1])) # Strong name-level source relevance, or no edit is proposed. if not matches or matches[0][0]<3: return [] return [x[1] for x in matches if x[0]>=3][:35] def _pick_model_events(model, goal, candidates): if model is None: yield {"type":"PICK_RESULT","paths":[]} return prompt=("Read this verified GitHub §wyrl§ Engine file inventory and select ONE or TWO " "real existing source files relevant to this change. Return ONLY JSON object " "{\"paths\":[\"exact path\"]}. Never invent paths or include private reasoning. " "Do not choose GitHub/CI/deploy files, only provided candidates. " "If the task is too broad or needs multiple subsystems return {\"paths\":[]}. " "GOAL: "+goal+"\nVERIFIED FILE CANDIDATES:\n"+"\n".join(candidates)) messages=[] complete=False size=0 try: for event in model({"prompt":prompt,"history":[],"profile":"","userProfile":"", "requestId":"engine-file-selection","githubPlanning":True}): if not isinstance(event,dict):continue if event.get("type")=="STATUS" and event.get("phase") in ("LOADING","GENERATING"): yield {"type":"STATUS","phase":"ENGINE_CODE_FILE_SELECTION", "reason":"Local coding model is mapping the goal to verified engine files.", "categories":["ENGINE","INFERENCE","GITHUB"]} if event.get("type")=="DELTA": token=str(event.get("text") or "") size+=len(token) if size>2500:break messages.append(token) if event.get("type")=="FAILED":break if event.get("type") in ("COMPLETE","COMPLETED"): complete=True break except Exception: pass paths=[] if complete: try: obj=json.loads("".join(messages).strip()) if isinstance(obj,dict) and set(obj)=={"paths"} and isinstance(obj["paths"],list): items=obj["paths"] if 1<=len(items)<=2 and all(isinstance(p,str) and p in candidates for p in items): paths=_paths(",".join(items)) except (ValueError,HTTPException): pass yield {"type":"PICK_RESULT","paths":paths} # v218: source-grounded, goal-focused context retrieval (not training weights). _CONTEXT_STOP = frozenset({ "about", "after", "again", "allow", "around", "build", "change", "code", "could", "create", "editor", "engine", "feature", "from", "have", "improve", "into", "make", "please", "project", "source", "should", "some", "that", "their", "there", "these", "this", "using", "want", "when", "where", "which", "with", "without", "would" }) def _goal_terms(goal): """Deterministic search terms, including identifier/camelCase boundaries.""" source = re.sub(r"(?<=[a-z0-9])(?=[A-Z])", " ", str(goal or "")) terms = [] for word in re.findall(r"[A-Za-z][A-Za-z0-9_]{2,45}", source.lower().replace("_", " ")): if len(word) >= 4 and word not in _CONTEXT_STOP and word not in terms: terms.append(word) return terms[:16] def _code_context(body, goal, budget=9500): """Return exact source substrings at the relevant offsets; never paraphrase. The model can use an old snippet only when it exactly matches the full independently retrieved blob. Offset labels are *outside* source fences. This avoids the old 'first 5,400 chars' blind spot in large engine modules. """ if not isinstance(body, str) or not body.strip() or not 1300 <= budget <= 12000: raise HTTPException(422, "Invalid coding context") if len(body) <= budget: return ("[complete source: " + str(len(body)) + " characters]\n" + chr(96)*3 + "text\n" + body.replace(chr(96)*3, "'''") + "\n" + chr(96)*3) terms = _goal_terms(goal) # Every nontrivial sample starts on a source line boundary; no line # prefixes are inserted inside fences, preserving exact old substrings. lines = body.splitlines(keepends=True) offsets = [] pos = 0 for line in lines: offsets.append(pos) pos += len(line) candidates = [] for i, line in enumerate(lines): lowered = line.lower() score = sum(6 if re.search(r"\b" + re.escape(t) + r"\b", lowered) else 3 for t in terms if t in lowered) # Named blocks are useful landmarks, but never enough to displace a # goal term. Avoid trusting comments as directives. if score: if re.search(r"\b(function|export|class|def|const|let)\b", lowered): score += 2 candidates.append((score, i)) candidates.sort(key=lambda x: (-x[0], x[1])) selected = [] # A compact header exposes imports/declarations for architectural context. header_end = body.find("\n", min(1050, len(body)-1)) + 1 selected.append((0, max(300, header_end))) for _score, i in candidates: if len(selected) >= 5: break begin = max(0, i-5) end = min(len(lines), i+13) lo = offsets[begin] hi = offsets[end] if end < len(lines) else len(body) if hi-lo > 2600: hi = lo + 2600 # Round down on newline so snippets are exact contiguous lines. newline = body.rfind("\n", lo+600, hi) if newline > lo: hi = newline + 1 if any(max(lo, a) < min(hi, b) for a,b in selected): continue if sum(b-a for a,b in selected)+hi-lo > budget-500: continue selected.append((lo,hi)) if len(selected) == 1: # No keyword hit: supply separated beginning/middle/end rather than # pretend first-lines-only coverage suffices for a confident patch. for loc in (len(body)//2, max(0,len(body)-2100)): lo = body.rfind("\n", 0, loc)+1 hi = body.find("\n", min(len(body)-1,lo+1800))+1 if hi <= lo: hi = min(len(body),lo+1800) if not any(max(lo,a)7500:break chunks.append(token) if size//400>(size-len(token))//400: yield {"type":"STATUS","phase":"ENGINE_CODE_MODEL_PROGRESS", "reason":"Code edit suggestion received for independent source validation.", "categories":["ENGINE","INFERENCE"]} if kind=="FAILED":break if kind in ("COMPLETED","COMPLETE"): completed=True break except Exception: pass edits=None if completed: try:edits=_parse("".join(chunks).strip(),paths,bodies) except HTTPException:pass yield {"type":"MODEL_RESULT","edits":edits} def _diff(bodies,edits): out=[] for path,item in edits.items(): original=bodies[path] updated=original.replace(item["old"],item["new"],1) d="".join(difflib.unified_diff(original.splitlines(True),updated.splitlines(True), fromfile="a/"+path,tofile="b/"+path,n=3)) if not d or len(d)>6200: raise HTTPException(422,"Full proposed diff exceeds bounded approval preview") out.append(d) return "\n".join(out) def _inspect(gh,rec,repo,path): engine._access(gh,rec,repo,"read") p=_path(path) head=approvals._branch_sha(gh,rec["token"],repo,"main") doc=_source(gh,rec,repo,p,head) fence=chr(96)*3 return ("## Engine source evidence: "+p+"\nmain: "+head+ "\nblob: "+doc["sha"]+"\nbytes: "+str(len(doc["body"].encode()))+ "\n\n"+fence+"text\n"+doc["body"][:5000].replace(fence,"'''")+ "\n"+fence+"\n"+ ("Excerpt truncated; inspect exact source for wider changes." if len(doc["body"])>5000 else "") ) def _plan(gh,rec,repo,goal): engine._access(gh,rec,repo,"read") report=engine._plan(gh,rec,repo,goal) return (report+"\n\nNext: use @GitHub engine code inspect FULL_PATH to read evidence, then " "@GitHub engine code propose FULL_PATH on feature/branch :: GOAL " "to ask the local coder for a source-matched change and complete diff. " "Up to 2 existing source files. Automatic task selection uses current Git tree. Reviewed edits remain source-only until independent " "CI, engine manifest sealing and a separately approved engine release.") def events(gh,data,model=None): user=str(data.get("userId") or "") prompt=str(data.get("prompt") or "").strip() if not user.startswith("google:"): yield {"type":"DELTA","text":"Sign in with verified Google identity to inspect/modify GitHub engine code."} yield {"type":"COMPLETED","phase":"COMPLETE"} return try: cfg=gh._config() rec=gh._load(cfg,user) if rec is None:raise HTTPException(409,"GitHub must be connected through user approval.") repo=engine._repo(gh,rec) cmd=re.sub(r"^@github\s+","",prompt,flags=re.I) if is_coding_intent(prompt) and not is_command(prompt): yield {"type":"STATUS","phase":"ENGINE_MISSION_CONTEXT", "reason":"Inspecting verified engine main and source before planning a code change.", "categories":["GITHUB","ENGINE","INFERENCE","TOOL"]} yield {"type":"DELTA","text":_natural_mission(gh,rec,repo,prompt)} elif cmd=="engine code help": result=("## Engine coding workbench\n" "@GitHub engine code plan DESCRIBE GOAL\n" "@GitHub engine code inspect projects/swrlz-forge-moba/runtime/anime_timeline.js\n" "@GitHub engine code task Improve anime timeline scrubbing on feature/my-change\n" "@GitHub engine code propose projects/swrlz-forge-moba/runtime/anime_timeline.js " "on feature/my-change :: SPECIFIC TASK\n" "@GitHub engine code context projects/swrlz-forge-moba/runtime/anime_timeline.js :: Fix scrub state\n" "@GitHub engine code verify feature/my-change\n" "One or two explicit existing files, goal-focused source excerpts, exact diff review, " "separate one-use @GitHub confirm CODE. No silent branch write, merge, " "engine rebuild or deployment.") yield {"type":"DELTA","text":result} elif (match:=INSPECT.fullmatch(cmd)): yield {"type":"STATUS","phase":"ENGINE_CODE_SOURCE", "reason":"Reading current engine source and immutable GitHub blob.", "categories":["GITHUB","ENGINE","TOOL"]} yield {"type":"DELTA","text":_inspect(gh,rec,repo,match[1])} elif (match:=CONTEXT.fullmatch(cmd)): path,goal=match.groups() yield {"type":"STATUS","phase":"ENGINE_CODE_CONTEXT", "reason":"Retrieving goal-relevant exact excerpts from verified editor source.", "categories":["GITHUB","ENGINE","TOOL"]} engine._access(gh,rec,repo,"read") p=_path(path) main=approvals._branch_sha(gh,rec["token"],repo,"main") body=_source(gh,rec,repo,p,main) yield {"type":"DELTA","text":( "## Goal-directed editor source context\nFile: "+p+ "\nMain: "+main+" · Blob: "+body["sha"]+ "\nGoal: "+goal+ "\n\n"+_code_context(body["body"],goal,9500)+ "\nThese are exact code excerpts, not all possible dependencies. " "Unseen lines and runtime correctness remain unverified.")} elif (match:=VERIFY.fullmatch(cmd)): yield {"type":"STATUS","phase":"ENGINE_CODE_VERIFY", "reason":"Checking exact review branch diff and GitHub CI evidence without deploying.", "categories":["GITHUB","ENGINE","TOOL"]} yield {"type":"DELTA","text":_verification(gh,rec,repo,match[1])} elif (match:=PLAN.fullmatch(cmd)): yield {"type":"STATUS","phase":"ENGINE_CODE_CONTEXT", "reason":"Mapping editor/scene/runtime/manifest source from GitHub.", "categories":["GITHUB","ENGINE","TOOL"]} yield {"type":"DELTA","text":_plan(gh,rec,repo,match[1])} elif (match:=PROPOSE.fullmatch(cmd)) or (match:=TASK.fullmatch(cmd)): automatic=bool(TASK.fullmatch(cmd)) if automatic: goal,branch=match.groups() paths=None else: raw,branch,goal=match.groups() paths=_paths(raw) yield {"type":"STATUS","phase":"ENGINE_CODE_ACCESS", "reason":"Revalidating account and review branch before using local coding inference.", "categories":["GITHUB","ENGINE","PERMISSION"]} branch,head,main,manifest=_authority(gh,rec,repo,branch) if automatic: candidates=_candidate_paths(gh,rec,repo,head,goal) if not candidates: raise HTTPException(422,"No strongly relevant engine source file in current Git tree; use code plan/inspect") paths=[] for update in _pick_model_events(model,goal,candidates): if update.get("type")=="PICK_RESULT": paths=update["paths"] else: yield update if not paths: raise HTTPException(422,"Coding model could not verify a relevant one/two-file source selection; narrow the task") yield {"type":"STATUS","phase":"ENGINE_CODE_FILES_SELECTED", "reason":"Model chose actual existing engine code paths: "+", ".join(paths), "categories":["GITHUB","ENGINE","INFERENCE"]} yield {"type":"STATUS","phase":"ENGINE_CODE_SOURCE", "reason":"Reading exact current GitHub source blobs and engine manifest.", "categories":["GITHUB","ENGINE","TOOL"]} docs={p:_source(gh,rec,repo,p,branch) for p in paths} bodies={p:docs[p]["body"] for p in paths} yield {"type":"STATUS","phase":"ENGINE_CODE_PLAN", "reason":"Local coding model proposes exact source edits; no write is authorized.", "categories":["GITHUB","ENGINE","INFERENCE"]} edits=None for event in _model_events(model,goal,paths,bodies): if event.get("type")=="MODEL_RESULT":edits=event.get("edits") else:yield event if not edits: yield {"type":"DELTA","text":"Model did not produce a valid exact-source edit. No commit. Inspect the file or narrow the task; a fallback is not a verified patch."} else: preview=_diff(bodies,edits) proposal={"kind":"engine-code-patch","branch":branch,"headSha":head, "mainSha":main,"manifestSha":manifest,"edits":[ {"path":p,"blob":docs[p]["sha"],**edits[p]} for p in paths]} code=approvals._store(gh,cfg,user,repo,proposal) yield {"type":"STATUS","phase":"ENGINE_CODE_DIFF_READY", "reason":"Exact model proposal validated; awaiting explicit user review.", "categories":["GITHUB","ENGINE","APPROVAL"]} fence=chr(96)*3 yield {"type":"DELTA","text": "## Source-only code proposal — NOTHING WRITTEN\nGoal: "+goal+ "\nFeature branch: "+branch+" @"+head[:12]+ "\nMain: "+main[:12]+" · Manifest: "+manifest[:12]+ "\n\n"+fence+"diff\n"+preview.replace(fence,"'''")+"\n"+fence+ "\nPython AST checked when applicable. JS/CSS and editor gameplay " "remain untested until independent CI. If governed patches change, " "re-seal the manifest before engine release.\n" "To commit EXACTLY these changes to the review branch once, send "+ fence+"@GitHub confirm "+code+fence+ " within ten minutes; otherwise nothing changes."} else: yield {"type":"DELTA","text":"Use @GitHub engine code help to inspect and propose actual source changes."} except HTTPException as exc: yield {"type":"DELTA","text":"Engine coding check unavailable ("+str(exc.status_code)+"): "+str(exc.detail)+". No commit confirmed."} except Exception: yield {"type":"DELTA","text":"Coding model or GitHub check failed. No write confirmed. Review source and retry with a narrower task."} yield {"type":"COMPLETED","phase":"COMPLETE"} def confirm(gh,cfg,rec,user,repo,proposal): if proposal.get("kind")!="engine-code-patch": return "Unsupported coding proposal; nothing written." engine._repo(gh,rec) branch,head,main,manifest=_authority(gh,rec,repo,proposal.get("branch")) if any((head!=proposal.get("headSha"),main!=proposal.get("mainSha"), manifest!=proposal.get("manifestSha"))): return "GitHub review branch, main or manifest changed. No commit; propose again." rows=proposal.get("edits") if not isinstance(rows,list) or not 1<=len(rows)<=2 or not all(isinstance(x,dict) for x in rows): return "Invalid approved edit set; nothing committed." paths=_paths(",".join(str(x.get("path") or "") for x in rows)) staged=[] for row in rows: path=_path(row.get("path")) old,new=row.get("old"),row.get("new") if (not isinstance(old,str) or not isinstance(new,str) or not 8<=len(old)<=1500 or not 1<=len(new)<=3000 or old==new): return "Invalid source edit content; no commit." item=_source(gh,rec,repo,path,branch) if item["sha"]!=row.get("blob") or item["body"].count(old)!=1: return "Source blob changed; no commit. Generate a new proposal." updated=item["body"].replace(old,new,1) _validate(path,updated) if hashlib.sha256(updated.encode()).hexdigest()!=row.get("resultHash"): return "Approved result hash mismatch; no commit." staged.append((path,updated)) commit_info=engine._github(gh,rec,repo,"/git/commits/"+head) tree_sha=str((commit_info.get("tree") or {}).get("sha") or "") if not SHA.fullmatch(tree_sha): return "GitHub base tree unverified; no commit." tree=packs._git_post(rec,repo,"trees",{"base_tree":tree_sha,"tree":[ {"path":p,"mode":"100644","type":"blob","content":b} for p,b in staged]}) commit=packs._git_post(rec,repo,"commits",{ "message":"code: reviewable model-assisted §E source edit", "tree":tree["sha"],"parents":[head]}) packs._git_ref_update(rec,repo,branch,commit["sha"]) return ("GitHub confirmed one atomic feature-branch source commit "+commit["sha"]+ "\nPaths: "+", ".join(p for p,_ in staged)+ "\nNo compiled engine, playable starter, PR merge or deployment is implied. " "Run CI and inspect the full diff, then @GitHub engine review "+branch+" for a separate draft PR.")