@12ui/design 0.2.67 → 0.2.68

package/runtime/codex-conversion/src/exports/react.mjs

@@ -0,0 +1,44 @@
+import {parse} from 'parse5';
+import {ownsEditableMarkup,editableMarkup} from './editable.mjs';
+const quote=JSON.stringify;
+const rename={charset:'charSet',contenteditable:'contentEditable',inputmode:'inputMode',class:'className',for:'htmlFor',tabindex:'tabIndex',readonly:'readOnly',maxlength:'maxLength',colspan:'colSpan',rowspan:'rowSpan',srcset:'srcSet',crossorigin:'crossOrigin',viewbox:'viewBox',preserveaspectratio:'preserveAspectRatio', 'xlink:href':'xlinkHref','xml:space':'xmlSpace'};
+const bool=new Set(['readonly','disabled','checked','selected','multiple','required','autofocus','hidden','controls','loop','muted','open']);
+const voids=new Set('area base br col embed hr img input link meta param source track wbr'.split(' '));
+function attrName(n){return rename[n]??(n.startsWith('aria-')||n.startsWith('data-')?n:n.replace(/-([a-z])/g,(_,x)=>x.toUpperCase()));}
+function styles(value){const declarations={}; for(const part of value.split(/;(?![^()]*\))/)){const i=part.indexOf(':');if(i<0)continue;const key=part.slice(0,i).trim();declarations[key.startsWith('--')?key:attrName(key)]=part.slice(i+1).trim();}return declarations;}
+function textContent(node){return node.nodeName==='#text'?node.value:(node.childNodes??[]).map(textContent).join('');}
+function selectValue(node){
+ const selected=[];
+ function visit(parent){for(const child of parent.childNodes??[]){
+  if(child.tagName==='option' && child.attrs.some(a=>a.name==='selected'))selected.push(child.attrs.find(a=>a.name==='value')?.value??textContent(child).replace(/[\t\n\f\r ]+/g,' ').trim());
+  else if(child.tagName==='optgroup')visit(child);
+ }}
+ visit(node);
+ return node.attrs.some(a=>a.name==='multiple')?selected:selected.at(-1);
+}
+function jsx(node,seams,editable){
+ if(node.nodeName==='#text')return `{${quote(node.value)}}`;
+ if(!node.tagName)return '';
+ if(node.tagName==='script'){seams.push('Source script omitted; implement application behavior explicitly.');return '';}
+ let attrs=(node.attrs??[]).map(({name,value,prefix})=>{if(prefix)name=prefix+':'+name;if(/^on/i.test(name)){seams.push(`Source ${name} handler omitted.`);return '';}
+ if(node.tagName==='option'&&name==='selected')return '';
+ if(['textarea','select'].includes(node.tagName)&&name==='value')return '';
+ if(name==='contenteditable'&&['true','false'].includes(value.toLowerCase()))return ` contentEditable={${value.toLowerCase()}}`;
+ if(name==='style')return ` style={${JSON.stringify(styles(value))}}`;
+ if(bool.has(name))return ` ${name==='checked'&&node.tagName==='input'?'defaultChecked':name==='autofocus'?'autoFocus':attrName(name)}={true}`;
+ if(name==='value'&&['input','textarea','select'].includes(node.tagName))name='defaultValue';
+ return ` ${attrName(name)}={${quote(value)}}`;}).join('');
+ if(!voids.has(node.tagName)&&node.tagName!=='textarea'&&ownsEditableMarkup(node)){const index=editable.push(editableMarkup(node,seams))-1;return `<${node.tagName}${attrs} dangerouslySetInnerHTML={editable${index}}/>`;}
+ if(node.tagName==='textarea')attrs+=` defaultValue={${quote(textContent(node))}}`;
+ if(node.tagName==='select'){const value=selectValue(node);if(value!==undefined)attrs+=` defaultValue={${quote(value)}}`;}
+ return voids.has(node.tagName)?`<${node.tagName}${attrs}/>`:`<${node.tagName}${attrs}>${node.tagName==='textarea'?'':(node.childNodes??[]).map(n=>jsx(n,seams,editable)).join('')}</${node.tagName}>`;
+}
+export async function toReact(html){
+ const doc=parse(html);const el=doc.childNodes.find(n=>'tagName' in n && n.tagName==='html');if(!el || !('childNodes' in el))throw Error('Missing HTML element');
+ const head=el.childNodes.find(n=>'tagName' in n && n.tagName==='head');const body=el.childNodes.find(n=>'tagName' in n && n.tagName==='body');const seams=[],editable=[];if(!head || !body || !('childNodes' in head) || !('childNodes' in body) || !('attrs' in body))throw Error('Missing document structure');
+ const bodyJsx=(body.childNodes??[]).map(n=>jsx(n,seams,editable)).join('');
+ // Page styles deliberately retain document selectors; packaging records the global scope.
+ const headJsx=(head.childNodes??[]).filter(n=>['style','link','title','meta'].includes('tagName' in n?n.tagName:'')).map(n=>jsx(n,seams,editable)).join('');
+ const bodyAttrs=Object.fromEntries((body.attrs??[]).map(a=>[a.name,a.value]));
+ return {code:`import React, {useLayoutEffect} from 'react';\n${editable.map((html,index)=>`const editable${index}={__html:${quote(html)}};`).join('\n')}\nexport default function ConvertedPage(){\nuseLayoutEffect(()=>{const attrs=${JSON.stringify(bodyAttrs)};const previous={};for(const [k,v] of Object.entries(attrs)){previous[k]=document.body.getAttribute(k);document.body.setAttribute(k,v);}return()=>{for(const [k,v] of Object.entries(previous)){if(v===null)document.body.removeAttribute(k);else document.body.setAttribute(k,v);}};},[]);\nreturn <>${headJsx}${bodyJsx}</>;\n}\n`,seams:[...new Set(seams)],cssScope:'document-global; mount one page per document; not an isolated embeddable widget'};
+}

package/runtime/codex-conversion/src/exports/viewport.mjs

@@ -0,0 +1,17 @@
+import {readFile} from 'node:fs/promises';
+import {resolve} from 'node:path';
+
+const positive = value => Number.isSafeInteger(value) && value > 0;
+/** Explicit viewport dimensions win; native source geometry supplies omitted ones. */
+export async function exportViewport(sourceDir, width, height) {
+  let manifest;
+  try { manifest = JSON.parse(await readFile(resolve(sourceDir, 'manifest.json'), 'utf8')); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  const source = manifest?.source;
+  const native = positive(source?.width) && positive(source?.height);
+  const resolvedWidth = width ?? (native ? source.width : 1440);
+  const resolvedHeight = height ?? (native ? source.height : 1000);
+  if (!positive(resolvedWidth) || !positive(resolvedHeight)) throw Error('Positive integer viewport required');
+  return {width: resolvedWidth, height: resolvedHeight, paginate: height !== undefined,
+    basis: native ? 'source dimensions with explicit overrides' : 'generic 1440x1000 viewport with explicit overrides'};
+}

package/runtime/codex-conversion/src/finish/index.mjs

@@ -0,0 +1,58 @@
+import {readFile, mkdir, writeFile, realpath} from 'node:fs/promises';
+import path from 'node:path';
+import {hash, writeJson} from '../run-store.mjs';
+import {bindHtml} from '../references.mjs';
+import {applyPatches} from './patch.mjs';
+
+/** Deterministic derivative of a manifest-backed conversion; never calls a model. */
+export async function finishOutput({sourceDir, patchFile, outputDir}) {
+  sourceDir = await realpath(sourceDir);
+  outputDir = path.resolve(outputDir);
+  outputDir = path.join(await realpath(path.dirname(outputDir)), path.basename(outputDir));
+  if (outputDir === sourceDir || outputDir.startsWith(sourceDir + path.sep)) throw Error('Output must be outside source directory');
+  const manifestBytes = await readFile(path.join(sourceDir, 'manifest.json'));
+  const manifest = JSON.parse(manifestBytes.toString('utf8'));
+  if (manifest.entrypoint !== 'index.html' || !Array.isArray(manifest.files)) throw Error('Expected conversion manifest with index.html');
+  const inputs = [], names = new Set();
+  for (const file of manifest.files) {
+    if (typeof file.path !== 'string' || path.isAbsolute(file.path) || file.path.split(/[\\/]/).some(p => !p || p === '.' || p === '..') || file.path === 'manifest.json' || names.has(file.path)) throw Error('Invalid manifest file path');
+    const resolved = await realpath(path.join(sourceDir, file.path));
+    if (!resolved.startsWith(sourceDir + path.sep)) throw Error('Manifest file escapes source');
+    const bytes = await readFile(resolved);
+    if (hash(bytes) !== file.sha256) throw Error(`Source hash mismatch: ${file.path}`);
+    names.add(file.path); inputs.push({file, bytes});
+  }
+  const original = inputs.find(item => item.file.path === 'index.html')?.bytes;
+  if (!original) throw Error('Manifest lacks index.html');
+  const raw = await readFile(patchFile), issues = [], recoveries = [];
+  let candidate = original, externalDependencies = manifest.externalDependencies ?? [];
+  try {
+    const proposed = applyPatches(original.toString('utf8'), JSON.parse(raw.toString('utf8')));
+    const assets = inputs.map(item => item.file.sourceOwnership).filter(Boolean);
+    const options = {supplementalNames: [...names].filter(name => name !== 'index.html')};
+    const checked = bindHtml(proposed, assets, options);
+    if (checked.supplemental.some(asset => !inputs.some(item => item.file.path === asset.name && hash(item.bytes) === hash(asset.bytes)))) throw Error('Patch introduces a new asset');
+    const prior = bindHtml(original.toString('utf8'), assets, options);
+    if (checked.externalDependencies.some(dep => !prior.externalDependencies.some(old => old.url === dep.url))) throw Error('Patch introduces an external dependency');
+    candidate = Buffer.from(checked.html); externalDependencies = checked.externalDependencies; recoveries.push(...checked.recoveries);
+  } catch (error) { issues.push(String(error.message ?? error)); }
+  const provenance = `finish-${hash(raw).slice(0, 12)}-${hash(original).slice(0, 12)}`;
+  if ([...names].some(name => name === provenance || name.startsWith(provenance + '/'))) throw Error('This patch provenance already exists; reuse the existing derivative');
+  await mkdir(outputDir); // Exclusive destination: never merge stale output.
+  const files = [];
+  for (const {file, bytes} of inputs) {
+    const content = file.path === 'index.html' ? candidate : bytes;
+    await mkdir(path.dirname(path.join(outputDir, file.path)), {recursive: true});
+    await writeFile(path.join(outputDir, file.path), content, {flag: 'wx'});
+    files.push({...file, sha256: hash(content)});
+  }
+  await mkdir(path.join(outputDir, provenance));
+  for (const [name, bytes] of [['original.html', original], ['patch.json', raw], ['original-manifest.json', manifestBytes]]) {
+    const relative = `${provenance}/${name}`;
+    await writeFile(path.join(outputDir, relative), bytes, {flag: 'wx'});
+    files.push({path: relative, sha256: hash(bytes)});
+  }
+  const result = {status: issues.length ? 'original-preserved' : 'complete', applied: !candidate.equals(original), issues, recoveries, modelCalls: 0, originalSha256: hash(original), candidateSha256: hash(candidate), provenance, entrypoint: 'index.html'};
+  await writeJson(path.join(outputDir, 'manifest.json'), {...manifest, files, externalDependencies, derivative: result});
+  return result;
+}

package/runtime/codex-conversion/src/finish/patch.mjs

@@ -0,0 +1,14 @@
+/** Apply disjoint, unique anchors against the original, never partially. */
+export function applyPatches(original, request) {
+  if (!Array.isArray(request?.patches)) throw Error('Expected patches array');
+  const spans = request.patches.map((patch, index) => {
+    if (typeof patch?.before !== 'string' || !patch.before || typeof patch.after !== 'string') throw Error(`Invalid patch ${index}`);
+    const start = original.indexOf(patch.before);
+    if (start < 0 || original.indexOf(patch.before, start + 1) >= 0) throw Error(`Patch ${index} anchor missing or ambiguous`);
+    return {start, end: start + patch.before.length, after: patch.after};
+  }).sort((a, b) => a.start - b.start);
+  for (let i = 1; i < spans.length; i++) if (spans[i].start < spans[i - 1].end) throw Error('Overlapping patch anchors');
+  let html = original;
+  for (const span of spans.reverse()) html = html.slice(0, span.start) + span.after + html.slice(span.end);
+  return html;
+}

package/runtime/codex-conversion/src/images/execute.mjs

@@ -0,0 +1,52 @@
+import {normalizeExternalFrame} from './frame-normalization.mjs';
+import {executeLocalGroup} from './local.mjs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {createHash} from 'node:crypto';
+import {prepareReference,cropProviderImage} from './geometry.mjs';
+import {operationPrompt} from './prompt.mjs';
+import {DEFAULT_IMAGE_ENDPOINT,requestImage,decodeImageResponse} from './provider.mjs';
+import {executeNativeCall,decodeNativeResponse} from './native.mjs';
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+// Derived artifacts may be recreated freely from the immutable provider response.
+async function save(file,bytes) { const temporary=`${file}.${process.pid}.tmp`; await fs.writeFile(temporary,bytes); await fs.rename(temporary,file); }
+async function executeGroup({group,sourceBytes,runDir,store,env,progress,fetchImpl,imageBackend,codexBinary,codexHome,timeoutMs}) {
+  if(group.operation==='crop-source')return executeLocalGroup({group,sourceBytes,runDir,progress});
+  const input=await prepareReference(sourceBytes,group);
+  const request=imageBackend==='native'?{backend:'native',model:'gpt-6-astra',effort:'medium',imageModel:null,normalization:'exact-stretch-lanczos3',expected:group.frame.output,prompt:operationPrompt(group,'native'),inputSha256:sha(input)}:{endpoint:env.CODEX_CONVERSION_IMAGE_ENDPOINT??DEFAULT_IMAGE_ENDPOINT,model:'gpt-image-2.5-flare',quality:'high',size:`${(group.frame.providerOutput??group.frame.output).width}x${(group.frame.providerOutput??group.frame.output).height}`,background:group.background,prompt:operationPrompt(group),inputSha256:sha(input)};
+  const callId=`image-${group.id}`;
+  const result=imageBackend==='native'?await executeNativeCall({request,input,callId,store,codexBinary,codexHome,timeoutMs}):await store.runCall(callId,request,async({persistMetadata})=>requestImage({request,input,apiKey:env.OPENAI_API_KEY,idempotencyKey:sha(JSON.stringify({runDir:path.resolve(runDir),callId,request})),persistMetadata,fetchImpl}),{prepare:async()=>{if(!env.OPENAI_API_KEY?.trim())throw Error('OPENAI_API_KEY is required for external Flare image execution');}});
+  const {png:providerPng,usage,revisedPrompt,native}=imageBackend==='native'?await decodeNativeResponse(result.bytes):{...decodeImageResponse(result.bytes,result.metadata),native:undefined};
+  const {png,transform}=imageBackend==='external'?await normalizeExternalFrame(providerPng,group.frame):{png:providerPng,transform:null};
+  const crops=await cropProviderImage(png,group);
+  await save(path.join(runDir,`${group.id}-provider.png`),providerPng);
+  if(transform)await save(path.join(runDir,`${group.id}-frame.png`),png);
+  const assets=[];
+  for(const asset of crops) {
+    const crop=asset.bytes, relativePath=`${asset.id}.png`;
+    await save(path.join(runDir,relativePath),crop);
+    const receipt={id:asset.id,path:relativePath,providerSha256:sha(providerPng),sha256:sha(crop),...(transform?{transform}:{}),crop:asset.crop,delivery:asset.delivery,operation:'Exact frozen source-owner crop, no localization/resizing/repacking/repair'};
+    await save(path.join(runDir,`${asset.id}-delivery.json`),JSON.stringify(receipt,null,2)+'\n');
+    assets.push(receipt);
+  }
+  const receipt={groupId:group.id,callId,request,rawResponseSha256:sha(result.bytes),providerSha256:sha(providerPng),metadata:result.metadata,usage,revisedPrompt,...(native?{native}:{}),...(transform?{transform}:{}),reused:result.reused};
+  await save(path.join(runDir,`${group.id}-receipt.json`),JSON.stringify(receipt,null,2)+'\n');
+  progress?.({phase:'image-complete',groupId:group.id,reused:result.reused});
+  return {assets,receipt};
+}
+export async function executeImages({plan,sourcePath,runDir,store,env=process.env,progress,fetchImpl=fetch,imageBackend='external',codexBinary='codex',codexHome=undefined,timeoutMs=1800000,nativeModel='gpt-6-astra'}) {
+  if(!['external','native'].includes(imageBackend))throw Error('Unsupported image backend');
+  if(nativeModel!=='gpt-6-astra')throw Error('Unsupported native model');
+  await fs.mkdir(runDir,{recursive:true});
+  const sourceBytes=await fs.readFile(sourcePath);
+  const results=await Promise.allSettled(plan.groups.map(group=>executeGroup({group,sourceBytes,runDir,store,env,progress,fetchImpl,imageBackend,codexBinary,codexHome,timeoutMs})));
+  await save(path.join(runDir,'artwork-results.json'),JSON.stringify(results.map((r,i)=>r.status==='fulfilled'?{groupId:plan.groups[i].id,status:r.status,receipt:r.value.receipt}:{groupId:plan.groups[i].id,status:r.status,error:String(r.reason)}),null,2)+'\n');
+  const failures=results.filter(r=>r.status==='rejected');
+  if(failures.length) {
+    const error=new AggregateError(failures.map(r=>r.reason),'Artwork incomplete; saved calls can be resumed without fallback or paid retries');
+    if(failures.some(r=>r.reason?.code==='NEEDS_RECONCILIATION'))Object.assign(error,{code:'NEEDS_RECONCILIATION'});
+    throw error;
+  }
+  const completed=results.filter(r=>r.status==='fulfilled').map(r=>r.value);
+  return {assets:completed.flatMap(r=>r.assets),usage:completed.map(r=>({groupId:r.receipt.groupId,usage:r.receipt.usage,metadata:r.receipt.metadata,reused:r.receipt.reused}))};
+}

package/runtime/codex-conversion/src/images/frame-normalization.mjs

@@ -0,0 +1,10 @@
+import sharp from 'sharp';
+import {createHash} from 'node:crypto';
+const hash=bytes=>createHash('sha256').update(bytes).digest('hex');
+export async function normalizeExternalFrame(providerPng,frame){
+ if(!frame.providerOutput)return {png:providerPng,transform:null};
+ const actual=await sharp(providerPng).metadata();
+ if(actual.width!==frame.providerOutput.width||actual.height!==frame.providerOutput.height)throw Error('Provider grid dimensions differ from the frozen request');
+ const png=await sharp(providerPng).resize(frame.output.width,frame.output.height,{fit:'fill',kernel:'lanczos3'}).png().toBuffer();
+ return {png,transform:{...frame.normalization,input:frame.providerOutput,output:frame.output,scaleX:frame.output.width/actual.width,scaleY:frame.output.height/actual.height,providerSha256:hash(providerPng),sha256:hash(png)}};
+}

package/runtime/codex-conversion/src/images/geometry.mjs

@@ -0,0 +1,9 @@
+import sharp from 'sharp';
+export async function prepareReference(sourceBytes,group) {
+  return sharp(sourceBytes).extract(group.frame.input).png().toBuffer();
+}
+export async function cropProviderImage(png,group) {
+  const meta=await sharp(png).metadata();
+  if(meta.width!==group.frame.output.width||meta.height!==group.frame.output.height) throw Error(`Incorrect provider dimensions for ${group.id}; no resize`);
+  return Promise.all(group.members.map(async asset=>({id:asset.id,bytes:await sharp(png).extract(asset.frame.crop).png().toBuffer(),crop:asset.frame.crop,delivery:asset.delivery})));
+}

package/runtime/codex-conversion/src/images/local-operation.mjs

@@ -0,0 +1,17 @@
+import sharp from 'sharp';
+import {createHash} from 'node:crypto';
+const hash=b=>createHash('sha256').update(b).digest('hex');
+const positive=n=>Number.isSafeInteger(n)&&n>0;
+// Declared pixels only: no interpretation of colors, content, or ownership.
+export async function executeLocalImageOperation({source,crop,output=undefined,mask=undefined,composite=[]}) {
+ const started=performance.now(), metadata=await sharp(source).metadata();
+ if(!crop||!['left','top','width','height'].every(k=>Number.isSafeInteger(crop[k]))||crop.left<0||crop.top<0||!positive(crop.width)||!positive(crop.height)||crop.left+crop.width>metadata.width||crop.top+crop.height>metadata.height)throw Error('Crop must be an integer rectangle inside the source');
+ let bytes=await sharp(source).extract(crop).png().toBuffer();
+ if(output){if(!positive(output.width)||!positive(output.height)||!['nearest','cubic','mitchell','lanczos2','lanczos3'].includes(output.kernel))throw Error('Explicit output dimensions and supported kernel required');bytes=await sharp(bytes).resize(output.width,output.height,{fit:'fill',kernel:output.kernel}).png().toBuffer();}
+ const size=await sharp(bytes).metadata();
+ /** @type {import('sharp').OverlayOptions[]} */ const steps=[];
+ if(mask){if(!mask.provenance)throw Error('Supplied mask provenance required');const m=await sharp(mask.input).metadata();if(m.width!==size.width||m.height!==size.height||!m.hasAlpha)throw Error('Supplied mask must have alpha and match output dimensions');steps.push({input:mask.input,blend:'dest-in'});}
+ for(const item of composite){if(item.blend!=='over'||!item.provenance||!Number.isSafeInteger(item.left)||!Number.isSafeInteger(item.top)||item.left<0||item.top<0)throw Error('Explicit over composition and provenance required');const m=await sharp(item.input).metadata();if(item.left+m.width>size.width||item.top+m.height>size.height)throw Error('Overlay outside output');steps.push({input:item.input,left:item.left,top:item.top,blend:'over'});}
+ if(steps.length)bytes=await sharp(bytes).ensureAlpha().composite(steps).png().toBuffer();
+ return {bytes,receipt:{operation:'declared-local-image',sourceSha256:hash(source),crop,output:output??{width:crop.width,height:crop.height,kernel:null},mask:mask?{sha256:hash(mask.input),provenance:mask.provenance}:null,composite:composite.map(x=>({sha256:hash(x.input),left:x.left,top:x.top,blend:x.blend,provenance:x.provenance})),sha256:hash(bytes),elapsedMs:performance.now()-started}};
+}

package/runtime/codex-conversion/src/images/local.mjs

@@ -0,0 +1,18 @@
+import {writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import {executeLocalImageOperation} from './local-operation.mjs';
+/** Executes only declared original opaque pixels; no provider dispatch. */
+export async function executeLocalGroup({group,sourceBytes,runDir,progress}) {
+ const assets=[];
+ for(const asset of group.members){
+  if(asset.operation!=='crop-source'||asset.background!=='opaque'||asset.named_removals.length)throw Error('Invalid local source crop declaration');
+  const {bytes,receipt:operation}=await executeLocalImageOperation({source:sourceBytes,crop:asset.owner});
+  const relativePath=`${asset.id}.png`;
+  await writeFile(path.join(runDir,relativePath),bytes);
+  const receipt={id:asset.id,path:relativePath,sha256:operation.sha256,crop:asset.owner,delivery:asset.delivery,operation};
+  await writeFile(path.join(runDir,`${asset.id}-delivery.json`),JSON.stringify(receipt,null,2)+'\n');assets.push(receipt);
+ }
+ const receipt={groupId:group.id,backend:'local',operation:'crop-source',paidCall:false,assets:assets.map(a=>({id:a.id,sha256:a.sha256})),usage:null,reused:false};
+ await writeFile(path.join(runDir,`${group.id}-receipt.json`),JSON.stringify(receipt,null,2)+'\n');
+ progress?.({phase:'image-complete',groupId:group.id,backend:'local'});return {assets,receipt};
+}

package/runtime/codex-conversion/src/images/native-collect.mjs

@@ -0,0 +1,43 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {parseNativeRecords, pngDimensions, geometryTreatments, sha256} from './native-records.mjs';
+
+async function custody(file, bytes) {
+  try { await fs.writeFile(file, bytes, {flag: 'wx'}); }
+  catch (error) { if (error.code !== 'EEXIST' || sha256(await fs.readFile(file)) !== sha256(bytes)) throw error; }
+}
+// Collection is repeatable and never launches inference or changes previous bytes.
+export async function collectNative({rolloutPaths, outputDir, expected}) {
+  await fs.mkdir(outputDir, {recursive: true});
+  const originals = [];
+  for (const [index, source] of rolloutPaths.entries()) {
+    const bytes = await fs.readFile(source), destination = path.join(outputDir, `rollout-${index}.jsonl`);
+    await custody(destination, bytes);
+    originals.push({source, path: destination, sha256: sha256(bytes)});
+  }
+  const audit = parseNativeRecords((await Promise.all(originals.map(f => fs.readFile(f.path, 'utf8')))).join('\n'));
+  const outputs = [];
+  for (const [index, generation] of audit.generations.entries()) {
+    if (!generation.bytes) continue;
+    const file = path.join(outputDir, `native-original-${index}.png`);
+    await custody(file, generation.bytes);
+    let savedPathMatches = null;
+    if (generation.savedPath) {
+      try { savedPathMatches = sha256(await fs.readFile(generation.savedPath)) === generation.outputSha256; }
+      catch (error) { if (error.code !== 'ENOENT') throw error; }
+    }
+    outputs.push({id: generation.id, path: file, sha256: generation.outputSha256, savedPathMatches, dimensions: pngDimensions(generation.bytes)});
+  }
+  const geometry = outputs.length === 1 ? geometryTreatments(outputs[0].dimensions, expected) : null;
+  const receipt = {...audit, generations: audit.generations.map(({bytes, ...rest}) => rest), originals, outputs, geometry,
+    state: outputs.some(output => output.savedPathMatches === false) ? 'custody-mismatch' : audit.state === 'completed-awaiting-dimensions' ? (geometry?.raw.status ?? 'unknown-missing-output') : audit.state,
+    accounting: 'Quota observations are account-wide snapshots, not per-image dollars or isolated consumption.',
+    recovery: 'Collect only. Never redispatch an existing claim, including unknown or failed outcomes.'};
+  await custody(path.join(outputDir, 'receipt.json'), JSON.stringify(receipt, null, 2) + '\n');
+  return receipt;
+}
+
+export async function packNativeReceipt(receipt) {
+ const originals=await Promise.all(receipt.outputs.map(async output=>({...output,base64:(await fs.readFile(output.path)).toString('base64')})));
+ return Buffer.from(JSON.stringify({...receipt,outputs:originals}));
+}

package/runtime/codex-conversion/src/images/native-files.mjs

@@ -0,0 +1,11 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function filesUnder(directory) {
+ const result=[];
+ for(const entry of await fs.readdir(directory,{withFileTypes:true})) {
+ const file=path.join(directory,entry.name);
+ if(entry.isDirectory()) result.push(...await filesUnder(file));
+ else if(entry.isFile()) result.push(file);
+ }
+ return result.sort();
+}

package/runtime/codex-conversion/src/images/native-invoke.mjs

@@ -0,0 +1,49 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {spawn} from 'node:child_process';
+import {createWriteStream} from 'node:fs';
+import {finished} from 'node:stream/promises';
+import {subscriptionEnv} from '../codex/home.mjs';
+import {filesUnder} from './native-files.mjs';
+import {collectNative,packNativeReceipt} from './native-collect.mjs';
+
+// Based on the successful C-N03 study invocation; separate from the no-tool planner.
+export function nativeArgv(spec, finalPath) {
+  return ['-a', 'never', 'exec', '--ignore-user-config', '--ignore-rules', '--strict-config', '-C', spec.workDir,
+    '--skip-git-repo-check', '-s', 'danger-full-access', '-m', 'gpt-6-astra', '-c', 'model_reasoning_effort="medium"',
+    '-c', 'model_provider="openai"', '-c', 'forced_login_method="chatgpt"', '-c', 'project_doc_max_bytes=0',
+    '--enable', 'skip_host_skill_discovery', '--json', '--color', 'never', '--output-last-message', finalPath,
+    '--image', spec.referencePath, '-'];
+}
+export async function invokeNative(spec, {callDir, persistMetadata}) {
+  await fs.mkdir(spec.workDir, {recursive: true});
+  const auth = spec.auth;
+  const finalPath = path.join(callDir, 'final.txt'), argv = nativeArgv(spec, finalPath);
+  const metadata = {model: 'gpt-6-astra', effort: 'medium', authentication: auth.authentication, home: auth.home, argv, startedAt: new Date().toISOString()};
+  await persistMetadata(metadata); // Private runtime location needed for collection after interruption.
+  await fs.writeFile(path.join(callDir, 'invocation.json'), JSON.stringify(metadata, null, 2) + '\n', {flag: 'wx'});
+  const stdout = createWriteStream(path.join(callDir, 'events.jsonl'), {flags: 'wx'});
+  const stderr = createWriteStream(path.join(callDir, 'stderr.log'), {flags: 'wx'});
+  const prompt = spec.prompt;
+  let timedOut = false, killTimer;
+  const child = spawn(spec.binary, argv, {cwd: spec.workDir, env: subscriptionEnv(auth.home), detached: true, stdio: ['pipe', 'pipe', 'pipe']});
+  const stop = signal => { if (child.pid) try { process.kill(-child.pid, signal); } catch (error) { if (error.code !== 'ESRCH') throw error; } };
+  const terminate = () => { stop('SIGTERM'); killTimer = setTimeout(() => stop('SIGKILL'), 5000); };
+  child.stdout.pipe(stdout); child.stderr.pipe(stderr); child.stdin.on('error', () => {}); child.stdin.end(prompt);
+  const timer = setTimeout(() => { timedOut = true; terminate(); }, spec.timeoutMs);
+  const interrupted = () => terminate();
+  process.once('SIGINT', interrupted); process.once('SIGTERM', interrupted);
+  const result = await new Promise(resolve => { child.once('error', error => resolve({spawnError: String(error)})); child.once('close', (exitCode, signal) => resolve({exitCode, signal})); });
+  clearTimeout(timer); clearTimeout(killTimer); stop('SIGTERM');
+  process.removeListener('SIGINT', interrupted); process.removeListener('SIGTERM', interrupted);
+  await Promise.all([finished(stdout), finished(stderr)]);
+  const events=(await fs.readFile(path.join(callDir,'events.jsonl'),'utf8')).split('\n').filter(Boolean).flatMap(line=>{try{return [JSON.parse(line)];}catch{return [{type:'malformed-event'}];}});
+  const diagnostics=events.filter(event=>['error','turn.failed','malformed-event'].includes(event.type));
+  const codexUsage=events.filter(event=>event.type==='turn.completed').map(event=>event.usage);
+  const completed = {...metadata, diagnostics, codexUsage, ...result, timedOut, finishedAt: new Date().toISOString()};
+  await persistMetadata(completed);
+  await fs.writeFile(path.join(callDir, 'completion.json'), JSON.stringify(completed, null, 2) + '\n', {flag: 'wx'});
+  const rolloutPaths = (await filesUnder(path.join(auth.home, 'sessions')).catch(error => error.code === 'ENOENT' ? [] : Promise.reject(error))).filter(file => file.endsWith('.jsonl'));
+  const receipt = await collectNative({rolloutPaths, outputDir: path.join(callDir, 'native-custody'), expected: spec.expected});
+  return {bytes: await packNativeReceipt(receipt), metadata: {...completed,nativeToolMs:receipt.toolMs,quotaBefore:receipt.quotaBefore,quotaAfter:receipt.quotaAfter,tokenUsage:receipt.tokenUsage}};
+}

package/runtime/codex-conversion/src/images/native-records.mjs

@@ -0,0 +1,57 @@
+import {createHash} from 'node:crypto';
+
+export const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
+export function pngDimensions(bytes) {
+  if (bytes.length < 24 || !bytes.subarray(0, 8).equals(Buffer.from('89504e470d0a1a0a', 'hex'))) throw Error('Native output is not a PNG');
+  return {width: bytes.readUInt32BE(16), height: bytes.readUInt32BE(20)};
+}
+
+// Preserve the source JSONL separately; this summary deliberately excludes base64.
+export function parseNativeRecords(text) {
+  const generations = new Map(), calls = new Map(), quota = [], tokenUsage = [], diagnostics = [], malformed = [];
+  let model = null, effort = null;
+  for (const [index, line] of text.split('\n').entries()) {
+    if (!line.trim()) continue;
+    let record;
+    try { record = JSON.parse(line); } catch { malformed.push(index + 1); continue; }
+    const p = record.payload ?? {}, item = p.item;
+    if (record.type === 'turn_context') { model = p.model ?? model; effort = p.effort ?? p.reasoning_effort ?? effort; }
+    if(p.type === 'token_count' && p.info) tokenUsage.push({timestamp:record.timestamp,...p.info});
+    if(['error','turn_aborted'].includes(p.type)) diagnostics.push({timestamp:record.timestamp,...p});
+    if (p.rate_limits) quota.push({line: index + 1, timestamp: record.timestamp, ...p.rate_limits});
+    if (p.type === 'custom_tool_call' && p.name === 'exec') {
+      const count = (p.input?.match(/tools\.image_gen__imagegen\s*\(/g) ?? []).length;
+      if (count) calls.set(p.call_id, {callId: p.call_id, count, line: index + 1, timestamp: record.timestamp});
+    }
+    if (p.type === 'function_call' && /^(image_gen[._]imagegen|image_gen__imagegen)$/.test(p.name ?? '')) calls.set(p.call_id, {callId: p.call_id, count: 1, line: index + 1, timestamp: record.timestamp});
+    if (item?.kind === 'image_gen.generation' && p.type === 'item_completed') {
+      const bytes = typeof item.result === 'string' ? Buffer.from(item.result, 'base64') : null;
+      const entry = {id: item.id, status: item.status, failure: item.failure ?? null, savedPath: item.savedPath ?? null,
+        transparentBackground: item.transparentBackground, revisedPrompt: item.revisedPrompt,
+        line: index + 1, timestamp: record.timestamp, threadId: p.thread_id, turnId: p.turn_id,
+        outputSha256: bytes ? sha256(bytes) : null, bytes};
+      if (generations.has(item.id) && generations.get(item.id).outputSha256 !== entry.outputSha256) throw Error('Conflicting native completion for ' + item.id);
+      generations.set(item.id, entry);
+    }
+  }
+  const count = [...calls.values()].reduce((sum, call) => sum + call.count, 0);
+  const completed = [...generations.values()];
+  const success = completed.length === 1 && completed[0].status === 'completed' && !completed[0].failure && completed[0].bytes;
+  const startedAt = [...calls.values()].map(call => call.timestamp).filter(Boolean).sort()[0];
+  const finishedAt = completed.map(item => item.timestamp).filter(Boolean).sort().at(-1);
+  const quotaBefore = quota.filter(item => startedAt && item.timestamp <= startedAt).at(-1) ?? null;
+  const quotaAfter = quota.find(item => finishedAt && item.timestamp >= finishedAt) ?? null;
+  return {model, effort, toolStartedAt:startedAt??null,toolFinishedAt:finishedAt??null,toolMs:startedAt&&finishedAt?Date.parse(finishedAt)-Date.parse(startedAt):null, calls: [...calls.values()], invocationCount: count, generations: completed, quota, quotaBefore, quotaAfter, tokenUsage, diagnostics, malformed,
+    state: malformed.length ? 'unknown-malformed-log' : count !== 1 ? (count > 1 ? 'protocol-violation-multiple-calls' : 'unknown-no-auditable-call') : success ? 'completed-awaiting-dimensions' : completed.length ? 'native-failed' : 'unknown-no-completion'};
+}
+
+export function geometryTreatments(actual, expected) {
+  const x = expected.width / actual.width, y = expected.height / actual.height;
+  const scale = Math.max(x, y);
+  return {
+    raw: {status: actual.width === expected.width && actual.height === expected.height ? 'exact-size-pass' : 'size-mismatch', actual, expected},
+    stretch: {name: 'exact-stretch', scaleX: x, scaleY: y, anisotropy: Math.max(x / y, y / x) - 1},
+    cover: {name: 'aspect-preserving-center-cover', scale, offsetX: (expected.width - actual.width * scale) / 2, offsetY: (expected.height - actual.height * scale) / 2},
+    selection: 'unselected-pending-multiple-case-registration-review',
+  };
+}

package/runtime/codex-conversion/src/images/native.mjs

@@ -0,0 +1,41 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import sharp from 'sharp';
+import {prepareHome} from '../codex/home.mjs';
+import {invokeNative} from './native-invoke.mjs';
+import {collectNative,packNativeReceipt} from './native-collect.mjs';
+import {filesUnder} from './native-files.mjs';
+import {sha256,pngDimensions,parseNativeRecords} from './native-records.mjs';
+
+export async function decodeNativeResponse(bytes) {
+  const receipt=JSON.parse(bytes.toString('utf8'));
+  if(!['exact-size-pass','size-mismatch'].includes(receipt.state)||receipt.outputs.length!==1) throw Error('Native image call requires inspection: '+receipt.state);
+  if(receipt.model!=='gpt-6-astra'||receipt.effort!=='medium')throw Error('Native coordinator model/effort does not match requested execution');
+  const original=Buffer.from(receipt.outputs[0].base64,'base64');
+  if(sha256(original)!==receipt.outputs[0].sha256) throw Error('Native original custody mismatch');
+  const actual=pngDimensions(original), expected=receipt.geometry.raw.expected;
+  const png=await sharp(original).resize(expected.width,expected.height,{fit:'fill',kernel:'lanczos3'}).png().toBuffer();
+  return {png,usage:{codexTokens:receipt.tokenUsage??[],imageUsage:null},revisedPrompt:receipt.generations[0].revisedPrompt??null,native:{originalPath:receipt.outputs[0].path,originalSha256:sha256(original),originalDimensions:actual,normalization:{name:'exact-stretch',kernel:'lanczos3',output:expected,scaleX:expected.width/actual.width,scaleY:expected.height/actual.height},model:receipt.model,effort:receipt.effort,imageModel:null,invocationCount:receipt.invocationCount}};
+}
+export async function executeNativeCall({request,input,callId,store,codexBinary='codex',codexHome,timeoutMs=1800000}) {
+  let auth;
+  return store.runCall(callId,request,async({callDir,persistMetadata})=>{
+    const referencePath=path.join(callDir,'reference.png');
+    await fs.writeFile(referencePath,input,{flag:'wx'});
+    const prompt=`This is an asset-execution task. Use tools.view_image once to inspect ${referencePath}. Then invoke tools.image_gen__imagegen exactly once with referenced_image_paths=[${JSON.stringify(referencePath)}] and the following prompt copied verbatim. Do not use shell, web, apps, other image providers, or image-editing code. No retries, extra calls, HTML work, or visual repair. If unavailable or unsuccessful, report failure. Emit the native image result with generatedImage and finish. Do not print base64.\n\nIMAGE PROMPT:\n${request.prompt}\n`;
+    return invokeNative({auth,binary:codexBinary,workDir:path.join(callDir,'work'),referencePath,prompt,timeoutMs,expected:request.expected},{callDir,persistMetadata});
+  },{prepare:async({callDir})=>{
+    const authHome=codexHome??process.env.CODEX_HOME??path.join(os.homedir(),'.codex');
+    auth=await prepareHome({authHome,binary:codexBinary,runDir:callDir});
+  },recover:async({callDir,metadata})=>{
+    if(!metadata?.home)return null;
+    const rolloutPaths=(await filesUnder(path.join(metadata.home,'sessions')).catch(error=>{if(error.code==='ENOENT')return [];throw error;})).filter(file=>file.endsWith('.jsonl'));
+    if(!rolloutPaths.length)return null;
+    const audit=parseNativeRecords((await Promise.all(rolloutPaths.map(file=>fs.readFile(file,'utf8')))).join('\n'));
+    if(audit.state!=='completed-awaiting-dimensions')return null;
+    const receipt=await collectNative({rolloutPaths,outputDir:path.join(callDir,'native-custody'),expected:request.expected});
+    if(!['exact-size-pass','size-mismatch'].includes(receipt.state))return null;
+    return {bytes:await packNativeReceipt(receipt),metadata:{...metadata,nativeToolMs:receipt.toolMs,quotaBefore:receipt.quotaBefore,quotaAfter:receipt.quotaAfter,tokenUsage:receipt.tokenUsage,collectionRecovery:true}};
+  }});
+}

package/runtime/codex-conversion/src/images/prompt.mjs

@@ -0,0 +1,14 @@
+export function operationPrompt(group,backend='external'){const {frame}=group;
+ if(frame.providerOutput&&backend==='external')return gridPrompt(group);
+ if(group.operation==='preserve-source')return `Upscale this complete original image to exactly ${frame.output.width} pixels wide by ${frame.output.height} pixels high. Preserve the original composition exactly: double every position and dimension, with no layout changes. Preserve ALL visible navigation text, captions, rules, gaps, and original materials and artwork, including their original crop, scale, texture, edges, and relative positions. Do not remove any content, redesign, rearrange, recenter, enlarge individual artwork, extend its framing, or add anything. Return the entire supplied image at exactly 2× resolution with faithfully clarified material detail. This is source-preserving upscaling of the whole reference, not a new layout.`;
+ const owners=group.members.map(a=>({rectangle:{left:a.owner.left-frame.input.left,top:a.owner.top-frame.input.top,width:a.owner.width,height:a.owner.height},desired_owner:a.desired_owner,remove_only:a.named_removals.map(r=>{const [x,y,w,h]=r.source_bbox_px,o=a.owner,left=Math.max(x,o.left),top=Math.max(y,o.top),right=Math.min(x+w,o.left+o.width),bottom=Math.min(y+h,o.top+o.height);return {text_or_element:r.text_or_element,rectangle:{left:left-frame.input.left,top:top-frame.input.top,width:right-left,height:bottom-top}};})}));
+ return `Return this complete original context at exactly ${frame.output.width}×${frame.output.height}, doubling every input coordinate. Preserve the original composition, artwork positions, extents, material detail and all neighboring content. Inside only the following INPUT-coordinate owner rectangles, deliver the desired underlying owner and remove only the explicitly named overlays in their listed INPUT-coordinate rectangles: ${JSON.stringify(owners)}. Rebuild the owner continuously where these overlays were removed. Declared removal facts have exclusive authority and override preservation instructions. Preserve only UNLISTED writing and details, including everything outside the owner rectangles. Do not recompose, recenter, enlarge, stretch or rearrange any element. Preserve the declared ${group.background} owner ground. No new readable content. The executor will take fixed source-coordinate crops; it cannot correct movement.`;
+}
+
+function gridPrompt(group){
+ const {frame}=group,size=frame.providerOutput;
+ const mapping=`Return the complete supplied original context at exactly ${size.width}×${size.height}. Map the entire ${frame.input.width}×${frame.input.height} input to that canvas proportionally on each axis, without padding, cropping or repositioning. These dimensions meet the provider grid; the executor will map the complete result to ${frame.output.width}×${frame.output.height} before taking exact source-owner crops.`;
+ if(group.operation==='preserve-source')return `${mapping} Preserve all visible writing, composition, artwork, texture and details. Clarify material detail without redesigning, adding, removing or rearranging content.`;
+ const owners=group.members.map(a=>({rectangle:{left:a.owner.left-frame.input.left,top:a.owner.top-frame.input.top,width:a.owner.width,height:a.owner.height},desired_owner:a.desired_owner,remove_only:a.named_removals.map(r=>{const [x,y,w,h]=r.source_bbox_px,o=a.owner,left=Math.max(x,o.left),top=Math.max(y,o.top),right=Math.min(x+w,o.left+o.width),bottom=Math.min(y+h,o.top+o.height);return {text_or_element:r.text_or_element,rectangle:{left:left-frame.input.left,top:top-frame.input.top,width:right-left,height:bottom-top}};})}));
+ return `${mapping} All following owner and removal rectangles use ORIGINAL INPUT coordinates. Inside only these owners, reconstruct the desired underlying material and remove only the explicitly named overlays: ${JSON.stringify(owners)}. Declared removal facts have exclusive authority. Preserve all unlisted content, all neighboring pixels and the declared ${group.background} ground. No new readable content, recentering, enlargement or rearrangement.`;
+}

package/runtime/codex-conversion/src/images/provider.mjs

@@ -0,0 +1,22 @@
+/** External Flare transport. Raw wire bytes are returned for durable custody before decoding. */
+export const DEFAULT_IMAGE_ENDPOINT = 'https://api.openai.com/v1/images/edits';
+export async function requestImage({request,input,apiKey,idempotencyKey,persistMetadata,fetchImpl=fetch}) {
+  if (!apiKey?.trim()) throw Error('OPENAI_API_KEY is required for external Flare image execution');
+  const started=performance.now(), requestStartedAt=new Date().toISOString();
+  const form=new FormData();
+  for (const [key,value] of Object.entries({model:request.model,prompt:request.prompt,quality:request.quality,n:'1',size:request.size,background:request.background,output_format:'png'})) form.set(key,value);
+  form.append('image[]',new Blob([input],{type:'image/png'}),'input-0.png');
+  const response=await fetchImpl(request.endpoint,{method:'POST',headers:{Authorization:`Bearer ${apiKey}`,'Idempotency-Key':idempotencyKey},body:form,signal:AbortSignal.timeout(600000)});
+  const metadata={status:response.status,headers:{requestId:response.headers.get('x-request-id'),processingMs:response.headers.get('openai-processing-ms')},requestStartedAt,responseHeadersAt:new Date().toISOString(),responseHeadersMs:Math.round(performance.now()-started)};
+  await persistMetadata(metadata);
+  const bytes=Buffer.from(await response.arrayBuffer());
+  return {bytes,metadata:{...metadata,bodyReceivedAt:new Date().toISOString(),bodyReceivedMs:Math.round(performance.now()-started)}};
+}
+export function decodeImageResponse(bytes,metadata) {
+  let payload;
+  try { payload=JSON.parse(bytes.toString('utf8')); } catch { throw Error('Saved image provider response is not JSON'); }
+  if(metadata.status<200||metadata.status>=300) throw Error(`Image provider returned HTTP ${metadata.status}; saved response requires inspection`);
+  const b64=payload?.data?.[0]?.b64_json;
+  if(typeof b64!=='string'||!b64||Buffer.from(b64,'base64').toString('base64')!==b64) throw Error('Saved image provider response contains no valid base64 image');
+  return {png:Buffer.from(b64,'base64'),usage:payload.usage??null,revisedPrompt:payload.data[0].revised_prompt??null};
+}

package/runtime/codex-conversion/src/output.mjs

@@ -0,0 +1,28 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { hash, writeJson } from './run-store.mjs';
+
+/** @param {{runDir:string,normalized:any,assets:any[],source:any,plan:any}} options */
+export async function publishOutput({ runDir, normalized, assets, source, plan }) {
+  const dir = path.join(runDir, 'output'); await mkdir(dir, { recursive: true });
+  const files = [];
+  for (const asset of assets) {
+    const bytes = await readFile(path.join(runDir, asset.path));
+    if (asset.sha256 && asset.sha256 !== hash(bytes)) throw new Error(`Asset identity changed: ${asset.id}`);
+    const name = `${asset.id}.png`;
+    await writeFile(path.join(dir, name), bytes);
+    files.push({ path: name, sha256: hash(bytes), width: asset.delivery.width, height: asset.delivery.height, sourceOwnership: plan.assets.find(item => item.id === asset.id) });
+  }
+  for (const asset of normalized.supplemental) {
+    await writeFile(path.join(dir, asset.name), asset.bytes);
+    files.push({ path: asset.name, sha256: hash(asset.bytes) });
+  }
+  await writeFile(path.join(dir, 'index.html'), normalized.html);
+  files.unshift({ path: 'index.html', sha256: hash(normalized.html) });
+  await writeJson(path.join(dir, 'manifest.json'), {
+    schemaVersion: 1, entrypoint: 'index.html', files, externalDependencies: normalized.externalDependencies,
+    source: { sha256: source.sha256, width: source.width, height: source.height },
+    format: 'html-css', nativeLayerDoc: false,
+  });
+  return { entrypoint: 'output/index.html', manifest: 'output/manifest.json' };
+}

package/runtime/codex-conversion/src/project/invoke.mjs

@@ -0,0 +1,35 @@
+import {open,readFile} from 'node:fs/promises';
+import {spawn} from 'node:child_process';
+import path from 'node:path';
+import {subscriptionEnv} from '../codex/home.mjs';
+import {writeJson,hash} from '../run-store.mjs';
+import {summarizeEvents} from '../codex/events.mjs';
+import {projectArgv} from './prompt.mjs';
+export async function invokeProject({config,runDir,home,binary,prompt}) {
+ const stdout=await open(path.join(runDir,'events.jsonl'),'wx'), stderr=await open(path.join(runDir,'stderr.log'),'wx');
+ const startedAt=new Date().toISOString(); let timedOut=false, interrupted=false, spawnError=null;
+ try {
+  const child=spawn(binary,projectArgv(config,runDir),{cwd:config.projectDir,env:subscriptionEnv(home),detached:true,stdio:['pipe',stdout.fd,stderr.fd]});
+  const stop=signal=>{if(child.pid)try{process.kill(-child.pid,signal);}catch(e){if(e.code!=='ESRCH')throw e;}};
+  let killTimer;
+  const terminate=()=>{stop('SIGTERM');killTimer=setTimeout(()=>stop('SIGKILL'),5000);};
+  const signal=()=>{interrupted=true;terminate();};
+  process.once('SIGINT',signal);process.once('SIGTERM',signal);
+  const timer=setTimeout(()=>{timedOut=true;terminate();},config.timeoutMs);
+  child.stdin.on('error',()=>{});child.stdin.end(prompt);
+  let exitCode=null,exitSignal=null;
+  try { await new Promise(resolve=>{child.once('error',e=>{spawnError={code:/** @type {NodeJS.ErrnoException} */ (e).code??null};});child.once('close',(code,sig)=>{exitCode=code;exitSignal=sig;resolve(undefined);});}); }
+  finally {clearTimeout(timer);clearTimeout(killTimer);stop('SIGTERM');process.removeListener('SIGINT',signal);process.removeListener('SIGTERM',signal);await stdout.sync();await stderr.sync();}
+  const final=await readFile(path.join(runDir,'final.txt')).catch(e=>{if(e.code==='ENOENT')return null;throw e;});
+  const execution={startedAt,finishedAt:new Date().toISOString(),exitCode,exitSignal,timedOut,interrupted,spawnError,finalSha256:final?hash(final):null};
+  await writeJson(path.join(runDir,'execution.json'),execution);
+  return execution;
+ }finally{await stdout.close();await stderr.close();}
+}
+export async function completion(runDir) {
+ const execution=await readFile(path.join(runDir,'execution.json'),'utf8').then(JSON.parse).catch(e=>{if(e.code==='ENOENT')return null;throw e;});
+ const events=await summarizeEvents(path.join(runDir,'events.jsonl')).catch(()=>null);
+ const final=await readFile(path.join(runDir,'final.txt')).catch(e=>{if(e.code==='ENOENT')return null;throw e;});
+ const complete=execution?.exitCode===0&&!execution.timedOut&&!execution.interrupted&&!execution.spawnError&&final?.length&&execution.finalSha256===hash(final)&&events?.usage.length>0&&!events.failed.length&&!events.errorsAfterCompletion.length&&!events.malformedJsonlLines.length;
+ return {status:complete?'complete':execution?'incomplete':'needs-reconciliation',execution,usage:events?.usage??[],diagnostics:events?.errors??[],threadId:events?.threadId??null,finalSha256:final?hash(final):null};
+}

package/runtime/codex-conversion/src/project/prompt.mjs

@@ -0,0 +1,13 @@
+export function projectPrompt(c,runDir) {
+ return `Apply the FIRST attached image, the selected redesign target, to the actual working application in ${c.projectDir}. The SECOND image is its current source UI for orientation. Inspect its code and existing assets first, then realize the target through the actual framework components and styles in this one bounded coding turn. Actual code and live data are authoritative over both screenshots.
+Preserve all content, controls, links, routes, state transitions, event handlers, API integration, real data and persistence. Do not replace the application with static HTML, mock behavior, fake data, a screenshot background, tracing or a full-page raster. Interpret layout, typography, colors, hierarchy and surfaces while retaining the application's meaning. Record any target content conflicting with real data.
+Reuse existing artwork and the existing icon library. CSS and proper vector icons are appropriate UI implementation; do not approximate genuine photographic or illustrative artwork with CSS/vector drawings. If necessary new artwork is unavailable, write ${runDir}/asset-requests.json with target-image region coordinates, purpose and desired processing for the parent to execute separately. Continue delivering the best valid application around unresolved artwork and report it honestly. This runner does not process image requests.
+Work only inside ${c.projectDir} and ${runDir}. Use an authentication/browser helper only by the exact command supplied below; it owns authentication. Do not read or print credentials, cookies, private auth state, secret files, raw runtime logs or database files. Do not commit, reset/reseed data, alter shared services or another project. Do not invoke 12ui, other agents, model APIs, image generation or paid services. No additional inference or automatic retry is authorized. Preserve project structure and scripts; keep changes modular and remove superseded styling.
+Verify the real application at ${c.width}x${c.height} and a relevant narrow width, using the supplied build/typecheck and behavior checks. Save captures and verification output in ${runDir}. A command exit is execution evidence, not visual quality proof. Report actual checks, target differences, unresolved limitations and asset requests. Preserve meaningful changes and normalize concrete recoverable defects without another model call.
+Automatic rule/skill discovery is disabled. The caller supplies all applicable project rules and exact runtime/build/browser/behavior context here:
+${c.instructions}
+`;
+}
+export function projectArgv(c,runDir) {
+ return ['-a','never','exec','--ignore-user-config','--ignore-rules','--strict-config','-C',c.projectDir,'--skip-git-repo-check','-s','danger-full-access','-m','gpt-6-astra','-c','model_reasoning_effort="low"','-c','model_provider="openai"','-c','forced_login_method="chatgpt"','-c','project_doc_max_bytes=0','--enable','skip_host_skill_discovery','--json','--color','never','--output-last-message',`${runDir}/final.txt`,'--image',`${runDir}/target.image`,'--image',`${runDir}/source.image`,'-'];
+}