quoxcli 0.3.1 → 0.5.0

package/vendor/dragonlab/integration/companions-v1/characters.mjs

@@ -0,0 +1,108 @@
+import {readFile} from 'node:fs/promises';
+import {fileURLToPath} from 'node:url';
+import {activityView as baseView} from '../hyperion-v3/activity.mjs';
+
+export const CHARACTERS=Object.freeze({
+  lucid:{name:'Lucid',version:'recovery V5',review:'../../design/lucid/recovery/review.mjs',power:'sweep',powerName:'Horizon Sweep',powerDuration:3200,arrival:{scene:'attach',duration:3200}},
+  hyperion:{name:'Hyperion',version:'V2 acting',review:'../../design/hyperion/v2/review.mjs',power:'cluster',powerName:'Cluster Forge',powerDuration:4800,arrival:{scene:'attach',duration:3400}},
+  seer:{name:'Seer',version:'V4 flowing eight',review:'../../design/seer/v4/review.mjs',power:'pattern',powerName:'Pattern Sight',powerDuration:5200,arrival:{scene:'swim',duration:5800}},
+  sentinel:{name:'Sentinel',version:'A solid (provisional)',review:'../../design/stage3/companion-review.mjs',power:'scorch',powerName:'Aegis Inferno',powerDuration:3800,arrival:{scene:'greeting',duration:2400}},
+  cipher:{name:'Cipher',version:'V2 network acting',review:'../../design/cipher/v2/review.mjs',power:'trace',powerName:'Trace Route',powerDuration:4800,arrival:{scene:'attach',duration:3200}},
+  vulcan:{name:'Vulcan',version:'V3 forge salute',review:'../../design/vulcan/v3/review.mjs',power:'forge',powerName:'Brimstone Forge',powerDuration:9000,arrival:{scene:'attach',duration:3600}},
+  quoxperticus:{name:'Quoxperticus',version:'V4 fleet conductor',review:'../../design/quoxperticus/v4/review.mjs',power:'orchestrate',powerName:'Fleet Conductor',powerDuration:10000,arrival:{scene:'attach',duration:3000}},
+  drago:{name:'Drago',version:'V4 scoped inferno',review:'../../design/drago/v4/review.mjs',power:'fire',powerName:'Scoped Inferno',powerDuration:6800,arrival:{scene:'attach',duration:3800}},
+});
+const ids=Object.keys(CHARACTERS);
+// Host scene -> art clip. Sentinel never shows 'all-clear' (needs verified evidence); Drago has no 'proud'/'curious'/'focus' clips.
+const SCENES=Object.freeze({
+  sentinel:{curious:'scan',focus:'scan',concerned:'failure',proud:'idle'},
+  // Cipher claims no network facts: 'restored'/'delay'/'broken' routes are simulated, so completion stays on plain listening.
+  cipher:{curious:'inspect',focus:'inspect',standby:'idle',concerned:'broken',proud:'idle'},
+  // Vulcan has only idle, fire and forge clips besides the entrance. 'fire' is a decorative flourish, so nothing here claims a build or a fault: every host mood rests on idle and the forge is the working power.
+  vulcan:{curious:'idle',focus:'idle',standby:'idle',concerned:'idle',proud:'idle'},
+  // Quoxperticus: 'skill' (select a skill) stands for attention; the fleet scene is simulated, so it only appears as the working power.
+  quoxperticus:{curious:'skill',focus:'skill',standby:'idle',concerned:'idle',proud:'idle'},
+  drago:{curious:'inspect',focus:'active',concerned:'concerned',proud:'acknowledge'},
+});
+const SENTINEL_MOOD=Object.freeze({idle:'cute',greeting:'cute',standby:'cute',scan:'alert',approval:'alert',failure:'alert',warden:'warden',brace:'warden',scorch:'warden'});
+export function character(id){
+  if(!Object.hasOwn(CHARACTERS,id))throw new Error(`Choose ${ids.slice(0,-1).join(', ')} or ${ids.at(-1)}.`);
+  return CHARACTERS[id];
+}
+export function modulePath(id){character(id);return fileURLToPath(new URL(`./${id}.mjs`,import.meta.url));}
+export function reviewPath(id){return fileURLToPath(new URL(character(id).review,import.meta.url));}
+/** Brief compact entrance on attach. Host facts that need attention (approval, issue) always pre-empt it. */
+export function arrivalView(id,state,now){
+  const {arrival}=character(id),elapsed=now-state.started;
+  if(!arrival||!(elapsed>=0)||elapsed>=arrival.duration)return null;
+  if(state.approvals.length||state.issue||state.terminal)return null;
+  return {scene:arrival.scene,time:elapsed,motionTime:elapsed,caption:state.phase==='connecting'?'Connecting…':'Following the conversation.'};
+}
+export function activityView(id,state,now,{arrival=false}={}){
+  const spec=character(id);
+  const entrance=arrival?arrivalView(id,state,now):null;
+  if(entrance)return entrance;
+  const v=baseView(state,now);
+  if(v.scene==='cluster')return {...v,scene:spec.power,time:v.time*spec.powerDuration/4800,caption:`Working · ${spec.powerName} visual`};
+  if(id==='lucid')return {...v,scene:({concerned:'uncertain',proud:'delighted'})[v.scene]??v.scene};
+  if(SCENES[id])return {...v,scene:(id==='sentinel'&&state.approvals.length?'approval':SCENES[id][v.scene])??v.scene};
+  return v;
+}
+export async function loadCharacter(id){
+  const spec=character(id);
+  if(id==='lucid'){
+    const [{parseMaster},{renderLucidCharacter}]=await Promise.all([
+      import('../../design/lucid/recovery/render.mjs'),import('../../design/lucid/recovery/character.mjs'),
+    ]);
+    const rig=parseMaster(await readFile(new URL('../../design/lucid/recovery/lucid-master.svg',import.meta.url),'utf8'));
+    return {...spec,render:(scene,time,options)=>renderLucidCharacter(rig,scene,time,options)};
+  }
+  if(id==='sentinel'){
+    const [{renderSentinelCharacter},{renderSentinelIcon}]=await Promise.all([
+      import('../../design/stage3/sentinel-character.js'),import('../../design/stage3/sentinel-icon.js'),
+    ]);
+    return {...spec,render:(scene,time,{cols,rows,mono=false,still=false}={})=>{
+      // The authored character refuses below 48x16 cells (shrinking it was never approved). Smaller slots get the approved shield icon.
+      if(cols<48||rows<16){
+        const h=Math.max(6,Math.min(rows,10)),w=Math.max(12,Math.min(cols,h*2));
+        return renderSentinelIcon({cols:w,rows:h,mono,mood:SENTINEL_MOOD[scene]??'cute'});
+      }
+      // Scan is not a loop; bounce it so a long job keeps sweeping without a restart pop.
+      const t=scene==='scan'&&!still?(u=>u<2500?u:5000-u)(time%5000):time;
+      return renderSentinelCharacter(scene,t,{cols,rows,mono,still});
+    }};
+  }
+  const {parseSvgRig}=await import('../../factory/svg-rig.mjs');
+  if(id==='cipher'){
+    const [rig,{renderCipher}]=await Promise.all([
+      readFile(new URL('../../design/cipher/v1/cipher-master.svg',import.meta.url),'utf8').then(parseSvgRig),
+      import('../../design/cipher/v2/character.mjs'),
+    ]);
+    return {...spec,render:(scene,time,options)=>renderCipher(rig,scene,time,options)};
+  }
+  if(id==='vulcan'){
+    const [rig,{renderVulcan}]=await Promise.all([
+      readFile(new URL('../../design/vulcan/v1/vulcan-master.svg',import.meta.url),'utf8').then(parseSvgRig),
+      import('../../design/vulcan/v3/character.mjs'),
+    ]);
+    return {...spec,render:(scene,time,options)=>renderVulcan(rig,scene,time,options)};
+  }
+  if(id==='quoxperticus'){
+    const [rig,{renderQuoxperticus}]=await Promise.all([
+      readFile(new URL('../../design/quoxperticus/v2/quoxperticus-master.svg',import.meta.url),'utf8').then(parseSvgRig),
+      import('../../design/quoxperticus/v4/character.mjs'),
+    ]);
+    return {...spec,render:(scene,time,options)=>renderQuoxperticus(rig,scene,time,options)};
+  }
+  if(id==='drago'){
+    const [rig,{renderDrago}]=await Promise.all([
+      readFile(new URL('../../design/drago/v1/drago-master.svg',import.meta.url),'utf8').then(parseSvgRig),
+      import('../../design/drago/v4/character.mjs'),
+    ]);
+    return {...spec,render:(scene,time,options)=>renderDrago(rig,scene,time,options)};
+  }
+  const source=id==='seer'?'../../design/seer/v1/seer-master.svg':'../../design/hyperion/v1/hyperion-master.svg';
+  const rig=parseSvgRig(await readFile(new URL(source,import.meta.url),'utf8'));
+  const render=id==='seer'?(await import('../../design/seer/v4/character.mjs')).renderSeer:(await import('../../design/hyperion/v2/character.mjs')).renderHyperion;
+  return {...spec,render:(scene,time,options)=>render(rig,scene,time,options)};
+}

package/vendor/dragonlab/integration/companions-v1/cipher.mjs

@@ -0,0 +1,2 @@
+import {createDragonCompanion} from './companion.mjs';
+export const createCompanion=options=>createDragonCompanion('cipher',options);

package/vendor/dragonlab/integration/companions-v1/companion.mjs

@@ -0,0 +1,63 @@
+import {performance} from 'node:perf_hooks';
+import {composeMessage} from '../../design/lucid/recovery/layout.mjs';
+import {character,CHARACTERS} from './characters.mjs';
+const ENTRANCE_MS=Object.fromEntries(Object.entries(CHARACTERS).map(([k,v])=>[k,v.arrival.duration]));
+import {loadDragonView} from './view.mjs';
+import {initialActivity,activityEvent} from '../hyperion-v3/activity.mjs';
+
+/** Shared display lifecycle. Host events choose expressions; art makes no decisions. */
+export async function createDragonCompanion(id,{output=process.stdout,now=()=>performance.now(),still=false,arrival=true,mono=false,persist=true}={}){
+  character(id);
+  // Piped output does not need to load or render any art.
+  const actor=output.isTTY?await loadDragonView(id,{still,arrival,mono}):null;
+  let state=initialActivity(now()),height=0,boundary=true,closed=false,disabled=false,timer,closing;
+  const erase=()=>{
+    if(!height)return;
+    output.write(`\x1b[${height}A\r`);
+    for(let i=0;i<height;i++)output.write('\x1b[2K\n');
+    output.write(`\x1b[${height}A\r`);height=0;
+  };
+  const draw=()=>{
+    if(closed||disabled||!output.isTTY||!boundary)return;
+    const cols=output.columns||80,rows=output.rows||24;
+    if(rows<5||cols<16)return;
+    const started=state.started;
+    // greeting-only: after the entrance the block is withdrawn for good (host text is untouched).
+    if(!persist&&!still&&now()-started>=ENTRANCE_MS[id]&&!state.approvals.length){erase();disabled=true;clearInterval(timer);return;}
+    const v=actor.view(state,now(),{cols,rows});
+    const lines=composeMessage(v.frame,actor.name.toUpperCase()+'\n'+v.caption,{terminalCols:cols});
+    if(lines.length>=rows)return;
+    erase();output.write(lines.join('\n')+'\n');height=lines.length;
+  };
+  const safeDraw=()=>{try{draw();}catch{disabled=true;clearInterval(timer);try{erase();}catch{}}};
+  // Reflow invalidates old cursor coordinates. Do not erase after resize.
+  const resize=()=>{height=0;disabled=true;clearInterval(timer);};
+  output.on?.('resize',resize);
+  safeDraw();
+  if(output.isTTY&&!disabled){timer=setInterval(safeDraw,1000/6);timer.unref?.();}
+  return {
+    event(event){if(!closed&&!closing){state=activityEvent(state,event,now());safeDraw();}},
+    write(text){
+      if(closed)return;
+      erase();output.write(text);
+      if(text.length)boundary=text.endsWith('\n');
+      if(boundary)safeDraw();
+    },
+    suspend(){erase();disabled=true;clearInterval(timer);},
+    close(){
+      if(closing)return closing;
+      // Set closing before starting async work so concurrent closes share cleanup.
+      closing=Promise.resolve().then(async()=>{
+        state=activityEvent(state,{type:'stream.closed'},now());
+        try{
+          if(output.isTTY&&!disabled&&!still&&state.phase==='complete'&&!state.issue&&!state.approvals.length){
+            const remaining=Math.max(0,2600-(now()-state.changed));
+            if(remaining)await new Promise(resolve=>setTimeout(resolve,remaining));
+          }
+          safeDraw();
+        }finally{closed=true;clearInterval(timer);output.off?.('resize',resize);}
+      });
+      return closing;
+    },
+  };
+}

package/vendor/dragonlab/integration/companions-v1/drago.mjs

@@ -0,0 +1,2 @@
+import {createDragonCompanion} from './companion.mjs';
+export const createCompanion=options=>createDragonCompanion('drago',options);

package/vendor/dragonlab/integration/companions-v1/hyperion.mjs

@@ -0,0 +1,2 @@
+import {createDragonCompanion} from './companion.mjs';
+export const createCompanion=options=>createDragonCompanion('hyperion',options);

package/vendor/dragonlab/integration/companions-v1/lucid.mjs

@@ -0,0 +1,2 @@
+import {createDragonCompanion} from './companion.mjs';
+export const createCompanion=options=>createDragonCompanion('lucid',options);

package/vendor/dragonlab/integration/companions-v1/quoxperticus.mjs

@@ -0,0 +1,2 @@
+import {createDragonCompanion} from './companion.mjs';
+export const createCompanion=options=>createDragonCompanion('quoxperticus',options);

package/vendor/dragonlab/integration/companions-v1/seer.mjs

@@ -0,0 +1,2 @@
+import {createDragonCompanion} from './companion.mjs';
+export const createCompanion=options=>createDragonCompanion('seer',options);

package/vendor/dragonlab/integration/companions-v1/sentinel.mjs

@@ -0,0 +1,2 @@
+import {createDragonCompanion} from './companion.mjs';
+export const createCompanion=options=>createDragonCompanion('sentinel',options);

package/vendor/dragonlab/integration/companions-v1/view.mjs

@@ -0,0 +1,28 @@
+import {artSlot} from '../../design/lucid/recovery/layout.mjs';
+import {initialActivity,activityEvent} from '../hyperion-v3/activity.mjs';
+import {character,loadCharacter,activityView} from './characters.mjs';
+
+/**
+ * Pure per-frame view for hosts that own their own screen (Quoxon's Ink, the CLI block).
+ * Same reducer, same renderer, same priorities as the line-based companion; no timers, no terminal control.
+ * view() returns {frame,caption,slot,name,scene}; frame is null when the terminal is too small for art.
+ */
+export async function loadDragonView(id,{still=false,arrival=true,mono=false,persist=true}={}){
+  character(id);
+  const actor=await loadCharacter(id);
+  return {
+    id,name:actor.name,arrivalMs:character(id).arrival.duration,
+    initial:initialActivity,
+    reduce:activityEvent,
+    view(state,now,{cols=80,rows=24}={}){
+      // Greeting-only: withdrawn for good once the entrance is over, unless an approval is pending.
+      if(!persist&&!still&&now-state.started>=character(id).arrival.duration&&!state.approvals.length)return {frame:null,caption:null,hidden:true,name:actor.name,scene:null};
+      const slot=artSlot(cols,Math.max(1,rows));
+      if(id==='seer'||id==='cipher'||id==='vulcan'||id==='quoxperticus'){slot.cols=Math.min(39,slot.cols);slot.rows=Math.min(11,slot.rows);}
+      const v=activityView(id,state,now,{arrival:arrival&&!still});
+      const result=slot.showArt?actor.render(v.scene,v.time,{...slot,still,mono,motionTime:v.motionTime}):null;
+      if(result&&!result.ok)throw new Error(result.code);
+      return {frame:result?.frame??null,caption:v.caption,slot,name:actor.name,scene:v.scene};
+    },
+  };
+}

package/vendor/dragonlab/integration/companions-v1/vulcan.mjs

@@ -0,0 +1,2 @@
+import {createDragonCompanion} from './companion.mjs';
+export const createCompanion=options=>createDragonCompanion('vulcan',options);

package/vendor/dragonlab/integration/hyperion-v3/activity.mjs

@@ -0,0 +1,76 @@
+// Host facts select expressions; the renderer never infers operational truth.
+export function initialActivity(now = 0) {
+  return { started: now, changed: now, received: now, turnId: null, phase: 'connecting',
+    approvals: [], tools: [], issue: false, terminal: false };
+}
+const id = x => typeof x === 'string' && x.length <= 256 ? x : null;
+export function activityEvent(s, e, now) {
+  if (!e || typeof e !== 'object' || !Number.isFinite(now) || now < s.received) return s;
+  if (e.turn_id && s.turnId && e.turn_id !== s.turnId && e.type !== 'turn.started') return s;
+  let n = { ...s, received: now };
+  const phase = p => { if (n.phase !== p) { n.phase = p; n.changed = now; } };
+  const key = id(e.call_id) || id(e.approval_id);
+  switch (e.type) {
+    case 'turn.started':
+      if (s.terminal || (id(e.turn_id) && e.turn_id !== s.turnId)) n = { ...initialActivity(now), approvals: s.approvals };
+      n.turnId = id(e.turn_id) || s.turnId; phase('thinking'); break;
+    case 'connected': phase('thinking'); break;
+    case 'thinking':
+      if (!s.terminal) phase(String(e.stage || '').includes('tool') ? 'working' : 'thinking'); break;
+    case 'chunk': case 'text.delta':
+      if (!s.terminal) phase('speaking'); break;
+    case 'tool.started':
+      if (s.terminal) return s;
+      if (key && !n.tools.includes(key)) n.tools = [...n.tools, key].slice(-256);
+      phase('working'); break;
+    case 'tool.finished':
+      if (s.terminal) return s;
+      n.tools = n.tools.filter(k => k !== key);
+      // Unknown and effect_unknown results are never promoted to success.
+      if (e.status !== 'ok') n.issue = true;
+      phase(n.tools.length ? 'working' : 'thinking'); break;
+    case 'approval.requested':
+      if (!key) return s;
+      if (!n.approvals.includes(key)) n.approvals = [...n.approvals, key].slice(-256);
+      break;
+    case 'approval.resolved':
+      if (!key || !n.approvals.includes(key)) return s;
+      n.approvals = n.approvals.filter(k => k !== key);
+      if (e.decision !== 'approved') n.issue = true;
+      break;
+    case 'error': n.issue = true; n.terminal = true; phase('error'); break;
+    case 'turn.finished':
+      if (s.terminal) return s;
+      n.terminal = true;
+      if (e.status !== 'completed' || n.tools.length) n.issue = true;
+      phase(e.status === 'completed' ? 'complete' : 'error'); break;
+    case 'done':
+      // Legacy text completion is not a verified task outcome.
+      if (!s.terminal) phase('response-ready'); break;
+    case 'stream.closed':
+      if (!s.terminal) { n.terminal = true; phase(s.phase === 'response-ready' ? 'response-ready' : 'disconnected'); }
+      break;
+    default: return s;
+  }
+  return n;
+}
+
+export function activityView(s, now) {
+  const age = Math.max(0, now - s.changed);
+  const view = (scene, caption, time = age) => ({ scene, caption, time, motionTime: Math.max(0, now - s.started) });
+  if (s.approvals.length) return view('curious', 'Waiting for your approval.');
+  if (s.issue) return view('concerned', 'Something needs attention.');
+  if (s.phase === 'disconnected') return view('standby', 'Stream ended; outcome unknown.');
+  if (!s.terminal && now - s.received > 30000) return view('standby', 'No recent activity update.');
+  if (s.phase === 'complete') return age < 2600 ? view('proud', 'Turn completed.') : view('idle', 'Ready for the next message.');
+  if (s.phase === 'response-ready') return view('idle', 'Response received.');
+  if (s.phase === 'connecting') return view('standby', 'Connecting…');
+  if (age < 250) return view('idle', 'Following the conversation.');
+  if (s.tools.length || s.phase === 'working') {
+    // A restrained visual flourish, at most once each 30 seconds of work.
+    const t = age % 30000;
+    return t >= 5000 && t < 9800 ? view('cluster', 'Working · Cluster Forge visual', t - 5000) : view('focus', 'Working.');
+  }
+  if (s.phase === 'thinking') return view('curious', 'Thinking.');
+  return view('focus', 'Responding.');
+}

package/vendor/dragonlab/lib/power-effects.js

@@ -0,0 +1,294 @@
+/**
+ * Transparent, terminal-cell-native signature power renderer.
+ *
+ * Draws Braille dots in a separate compositing layer. Does not alter Quox's
+ * vendored renderer, write terminal escapes, set backgrounds, use randomness
+ * or perform actions. Times are deterministic milliseconds.
+ *
+ * Coordinates are in terminal cells; 2x4 Braille dots per cell.
+ */
+import { POWER_BY_SCENE } from './power-registry.js';
+
+const PI=Math.PI, TAU=2*PI;
+const clamp=(x,a=0,b=1)=>Math.max(a,Math.min(b,x));
+const ease=(u)=>{const q=clamp(u);return q*q*(3-2*q);};
+const phase=(t,a,b)=>ease((t-a)/Math.max(1,b-a));
+const rgb={
+  azure:[73,163,255],shield:[100,205,255],burn:[91,224,255],
+  threat:[250,87,91],ember:[255,165,78],gold:[255,190,86],
+  teal:[76,232,182],green:[85,245,153],
+  violet:[183,140,255],muted:[147,155,184],white:[225,236,255],
+};
+const bit=[
+  [0x01,0x08],
+  [0x02,0x10],
+  [0x04,0x20],
+  [0x40,0x80],
+];
+const fakeHash=n=>{
+  let x=Math.imul((n|0)^0x9e3779b9,0x85ebca6b);
+  x^=x>>>13;x=Math.imul(x,0xc2b2ae35);x^=x>>>16;
+  return (x>>>0)/4294967296;
+};
+function empty(c){return !c||c.ch===' '||c.ch==='\u2800';}
+
+export function spriteBounds(frame){
+  const w=frame[0]?.length||0,h=frame.length;
+  let minX=w,maxX=0,minY=h,maxY=0,n=0;
+  for(let y=0;y<h;y++)for(let x=0;x<w;x++){
+    if(empty(frame[y][x]))continue;
+    minX=Math.min(minX,x);maxX=Math.max(maxX,x);
+    minY=Math.min(minY,y);maxY=Math.max(maxY,y);n++;
+  }
+  return n?{minX,maxX,minY,maxY,centerX:(minX+maxX)/2,centerY:(minY+maxY)/2,visible:n}:
+    {minX:Math.floor(w*.35),maxX:Math.floor(w*.65),minY:Math.floor(h*.2),maxY:Math.floor(h*.8),centerX:w/2,centerY:h/2,visible:0};
+}
+
+function createCanvas(w,h,{mono=false,theme='dark'}={}){
+  const masks=new Uint8Array(w*h);
+  const ink=Array(w*h).fill(null);
+  const labels=new Map();
+  const col=c=>{
+    if(mono)return null;
+    if(theme==='light')return c.map(v=>Math.round(v*.68));
+    return c;
+  };
+  function dot(dx,dy,c=rgb.white){
+    const x=Math.round(dx),y=Math.round(dy);
+    // Keep a blank perimeter. Never put anything in the final column.
+    if(x<2||y<1||x>=w*2-2||y>=h*4-1)return;
+    const cx=Math.floor(x/2),cy=Math.floor(y/4),i=cy*w+cx;
+    masks[i]|=bit[y%4][x%2];ink[i]=col(c);
+  }
+  function point(x,y,c=rgb.white,r=0){
+    const xx=x*2,yy=y*4,rr=Math.max(0,r);
+    if(rr===0){dot(xx,yy,c);return;}
+    for(let dx=-rr;dx<=rr;dx++)for(let dy=-rr;dy<=rr;dy++){
+      if(dx*dx+dy*dy<=rr*rr+.15)dot(xx+dx,yy+dy,c);
+    }
+  }
+  function line(ax,ay,bx,by,c=rgb.white,thickness=0){
+    const dx=(bx-ax)*2,dy=(by-ay)*4,steps=Math.max(1,Math.ceil(Math.hypot(dx,dy)*1.8));
+    for(let i=0;i<=steps;i++){
+      const p=i/steps;
+      point(ax+(bx-ax)*p,ay+(by-ay)*p,c,thickness);
+    }
+  }
+  function arc(cx,cy,rx,ry,a0,a1,c=rgb.white,thickness=0){
+    const steps=Math.max(12,Math.ceil((Math.abs(rx)+Math.abs(ry)*2)*Math.abs(a1-a0)*2));
+    for(let i=0;i<=steps;i++){
+      const a=a0+(a1-a0)*(i/steps);
+      point(cx+Math.cos(a)*rx,cy+Math.sin(a)*ry,c,thickness);
+    }
+  }
+  function spark(cx,cy,t,r,c=rgb.white){
+    if(r<=0)return;
+    for(let k=0;k<7;k++){
+      const a=k*TAU/7+t*.0023;
+      line(cx+Math.cos(a)*.2,cy+Math.sin(a)*.14,
+        cx+Math.cos(a)*r,cy+Math.sin(a)*r*.5,c);
+    }
+  }
+  function glyph(x,y,ch,c=rgb.white){
+    const xx=Math.round(x),yy=Math.round(y);
+    if(xx<1||yy<0||xx>=w-1||yy>=h)return;
+    labels.set(yy*w+xx,{ch,rgb:col(c),bg:null});
+  }
+  function compose(base){
+    return base.map((row,y)=>row.map((cell,x)=>{
+      if(!empty(cell))return cell;
+      const i=y*w+x,mark=labels.get(i);
+      if(mark)return mark;
+      return masks[i]?{ch:String.fromCodePoint(0x2800+masks[i]),rgb:ink[i],bg:null}:cell;
+    }));
+  }
+  return {w,h,point,line,arc,spark,glyph,compose};
+}
+
+function positions(g){
+  const {minX,maxX,centerY}=g;
+  // Accent zone on left of the body, where the Q usually has room for fire.
+  return {
+    left:minX,
+    near:Math.max(3,minX-3),
+    mouth:minX+Math.max(5,Math.min(12,(maxX-minX)*.29)),
+    y:centerY+1,
+    mx:(minX+maxX)/2,
+  };
+}
+function sentinel(canvas,g,t,anchors){
+  const {point,line,arc,spark}=canvas,p=positions(g);
+  const {left}=p,y=anchors?.mouth?.y??p.y;
+  const mouthX=anchors?.mouth?.x??p.mouth;
+  const h=canvas.h;
+  const approach=phase(t,100,920),barrier=phase(t,580,1060),flame=phase(t,1200,2800);
+  // Two approaching abstract threat fragments, never a person or actual target.
+  for(let k=0;k<3;k++){
+    const dx=Math.max(3,left-20+k*2), dest=Math.max(3,left-5);
+    const px=dx+(dest-dx)*approach;
+    const py=h*(.37+k*.115)+Math.sin(t*.003+k)*.3;
+    if(t<1650){
+      line(px-.7,py-.27,px+.7,py+.27,rgb.threat,1);
+      line(px-.3,py+.45,px+.65,py-.35,rgb.threat);
+    }else if(t<3200){
+      for(let j=0;j<7;j++){
+        const a=j*TAU/7+k*2, dist=(t-1600)/180*(.3+fakeHash(k*73+j)*.6);
+        const glow=t<2300?rgb.ember:rgb.muted;
+        point(dest+Math.cos(a)*dist,py+Math.sin(a)*dist*.42,glow);
+      }
+    }
+  }
+  // Azure crescent shields the vulnerable LEFT face and flickers on collision.
+  if(t>480&&t<3480){
+    const sx=Math.max(4,Math.min(left+5,mouthX-2)),
+      rx=Math.max(2.5,Math.min(11,left*.34)),ry=Math.max(2.4,h*.36);
+    const sweep=phase(t,480,1000);
+    arc(sx,y,rx,ry,PI/2+(.6*(1-sweep)),3*PI/2-(.6*(1-sweep)),
+      t<1050?rgb.azure:rgb.shield, t>800&&t<1180?1:0);
+    if(t>800&&t<1520){
+      const intensity=1-phase(t,1120,1550);
+      spark(Math.max(2,sx-rx),y-.5,t,2.0*intensity,rgb.shield);
+    }
+  }
+  // Forward-facing defensive blue fire. The Q's eyes/body are not overwritten.
+  // It is a DEMO of scorched hostile symbols, never an asserted mitigation.
+  if(t>1200&&t<3300){
+    const reach=Math.max(3,Math.min(25,mouthX-3));
+    for(let i=0;i<65;i++){
+      const f=i/65, born=1230+f*1550+(fakeHash(i*11+5)-.5)*180, age=t-born;
+      if(age<0||age>750)continue;
+      const u=clamp(age/700),dist=reach*u*(.8+fakeHash(i+9)*.3);
+      // Emitted at the actual dragon's snout, not at an assumed Q-ring.
+      const px=mouthX-dist,py=y-.2+Math.sin(i*3.17+u*11)*(.2+u*.85);
+      point(px,py,u<.45?rgb.burn:rgb.azure,(i%11===0)?1:0);
+      if(i%9===0)point(px-1,py-.2,rgb.white);
+    }
+  }
+  if(t>3250)point(left+5,y,rgb.azure,1);
+}
+function lucid(c,g,t){
+  const {point,arc,line,glyph}=c,p=positions(g),l=Math.max(3,p.left-4),y=c.h*.52;
+  const sweep=phase(t,450,2600);
+  // Observations radiate outward; the 'unknown' remains explicitly marked.
+  if(t>300){
+    for(let k=1;k<=3;k++){
+      const radius=2+k*2.2*sweep;
+      arc(l+1,y,radius,radius*.35,PI*.85,PI*1.9,rgb.violet);
+    }
+    line(l+1,y,l+1+Math.min(9,p.left*.42)*Math.cos(-1.9+sweep*TAU),
+      y+Math.min(3,c.h*.19)*Math.sin(-1.9+sweep*TAU),rgb.white);
+    if(t>1750){glyph(Math.max(2,l-4),Math.round(y)-2,'?',rgb.muted);point(Math.max(3,l-1),y+.4,rgb.violet);}
+  }
+}
+function hyperion(c,g,t){
+  const {line,point,arc,glyph}=c,p=positions(g);
+  const left=Math.max(3,p.left-12),y=c.h*.49;
+  const lift=phase(t,250,1100),built=phase(t,1100,2650);
+  // A tiny 3-D guest container built one edge at a time.
+  if(lift>0){
+    arc(p.left+3,y-1,Math.min(8,p.left*.25),Math.min(3,c.h*.2),PI,2*PI,rgb.gold);
+  }
+  const w=6+Math.min(5,p.left*.18),h=Math.min(3.2,c.h*.16);
+  line(left,y,left+w*built,y,rgb.gold);
+  line(left,y,left,y+h*built,rgb.gold);
+  if(t>1500){
+    line(left+w*built,y,left+w*built,y+h*built,rgb.ember);
+    line(left,y+h*built,left+w*built,y+h*built,rgb.ember);
+  }
+  if(t>2400&&t<3650){
+    const x=left+w/2,yy=y+h/2;point(x,yy,rgb.gold,1);glyph(Math.round(x),Math.round(yy),'◆',rgb.white);
+  }
+}
+function seer(c,g,t){
+  const {line,arc,point,glyph}=c,p=positions(g);
+  const x0=Math.max(2,p.left-21),x1=Math.max(x0+7,p.left-3),y=c.h*.53;
+  const progress=phase(t,350,2850);
+  const gap=x0+(x1-x0)*.58;
+  for(let i=0;i<7;i++){
+    const x=x0+(x1-x0)*i/6;
+    if((x-x0)/(x1-x0)>progress)continue;
+    if(Math.abs(x-gap)<2&&t<2200)continue;
+    point(x,y+Math.sin(i*.9)*.55,rgb.teal,1);
+    if(i&&i!==4&&progress>i/6)line(x-1.4,y+.1,x-.5,y+.1,rgb.green);
+  }
+  if(t>1600){
+    const rx=1.4+Math.sin(t/380)*.18;
+    arc(gap,y,rx,rx*.72,0,TAU,rgb.white);
+    if(t>2450)glyph(Math.round(gap),Math.round(y),'•',rgb.green);
+  }
+}
+function nova(c,g,t){
+  const {line,point,arc,spark}=c,p=positions(g);
+  const x0=Math.max(2,p.left-25),x1=Math.max(x0+8,p.left-2),y=c.h*.55;
+  const thrust=phase(t,500,2250),travel=x0+(x1-x0)*thrust;
+  for(let i=0;i<5;i++){
+    const x=x0+(x1-x0)*i/4;
+    point(x,y+(i%2)*.5,rgb.green,1);
+    if(i>0&&t>350)line(x-2,y,x-1,y,rgb.teal);
+  }
+  if(t>450&&t<2750){
+    spark(travel,y+.1,t,1.4,rgb.green);
+    for(let i=0;i<9;i++){
+      const trail=travel-i*1.1;
+      if(trail<=x0-2)continue;
+      point(trail,y+.4*Math.sin(t*.013+i),i%3?rgb.green:rgb.white);
+    }
+  }
+  if(t>2200)arc(x1,y,2.2,1.2,0,TAU*.8,rgb.green);
+}
+function vulcan(c,g,t){
+  const {point,line,spark,glyph}=c,p=positions(g);
+  const x=Math.max(4,p.left-13),y=c.h*.49;
+  glyph(x,Math.round(y),'〈',rgb.teal);glyph(x+8,Math.round(y),'〉',rgb.teal);
+  line(x+1,y+2,x+7,y+2,rgb.muted);
+  if(t>500&&t<1900){
+    const q=phase(t,500,1600);
+    line(x+4,y-3,x+4-q*2,y-1+q*3,rgb.teal,1);
+    point(x+4-q*2,y-1+q*3,rgb.white);
+  }
+  if(t>1600&&t<2700){
+    spark(x+4,y+2,t,2.1*(1-phase(t,2100,2700)),rgb.ember);
+    point(x+4,y+2,rgb.white,1);
+  }
+  if(t>2750) {
+    for(let i=0;i<3;i++)point(x+2+i*2,y+1.5,rgb.teal);
+  }
+}
+function quox(c,g,t){
+  const {arc,point,line,spark}=c,p=positions(g);
+  const left=Math.max(4,p.left-13),cx=Math.max(5,p.left-6),cy=c.h*.5;
+  for(let i=0;i<4;i++){
+    const a=i*TAU/4+phase(t,450,2850)*TAU*.8;
+    const r=3.5+phase(t,300,1650)*3;
+    const tx=cx+Math.cos(a)*r*1.7,ty=cy+Math.sin(a)*r*.8;
+    if(t>350) {
+      point(tx,ty,i%2?rgb.violet:rgb.azure,1);
+      if(t>1200&&t<3100)line(tx,ty,cx,cy,rgb.muted);
+    }
+  }
+  if(t>2100&&t<3300)spark(cx,cy,t,2.4,rgb.white);
+}
+
+const DRAWERS=Object.freeze({
+  quox,lucid,hyperion,seer,sentinel,nova,vulcan,
+});
+
+/**
+ * Visual-only signature action. Base frame is immutable.
+ * Even at 32 columns, clamps effects to a blank perimeter.
+ * A static image can be requested by using still=true.
+ */
+export function renderPower(scene,t,base,{still=false,theme='dark',mono=false,anchors=null}={}){
+  const profile=POWER_BY_SCENE.get(scene);
+  if(!profile)throw new RangeError('Unknown power: '+scene);
+  if(!Array.isArray(base)||!base.length||!Array.isArray(base[0]))
+    throw new TypeError('Power base must be a nonempty matrix of terminal cells.');
+  const h=base.length,w=base[0].length;
+  if(h<9||w<32||base.some(row=>row.length!==w))
+    throw new RangeError('Power viewport must be rectangular, at least 32×9.');
+  const canvas=createCanvas(w,h,{theme,mono});
+  const time=still?Math.min(profile.duration*.6,2100):clamp(Number.isFinite(t)?t:0,0,profile.duration);
+  DRAWERS[profile.id](canvas,spriteBounds(base),time,anchors);
+  const result=canvas.compose(base);
+  return result;
+}