quoxcli 0.3.1 → 0.4.0

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;
+}

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

@@ -0,0 +1,74 @@
+/**
+ * Signature powers: visual-only, source-of-truth DISPLAY NAMES.
+ *
+ * No power performs an agent action. The Quox host may select a power on a
+ * witnessed event, but must NEVER infer success or mitigation from the art.
+ * Non-animated small/still fallbacks are supported by the same pure renderer.
+ */
+export const POWERS = Object.freeze([
+  {
+    displayName:'Quox',id:'quox',scene:'power-quox',base:'hero',duration:3600,
+    name:'Convergence',tagline:'Calls the constellation together',
+    effect:'Cyan and violet threads bring distant sparks into an orbit around the original Q.',
+    attach:'Quox here. Who shall we bring together?',
+    phases:['summon','connect','converge','settle'],
+    visualOnly:true,
+  },
+  {
+    displayName:'Lucid',id:'lucid',scene:'power-lucid',base:'situation',duration:3600,
+    name:'The Unveiling',tagline:'Reveals what is known, and the gaps',
+    effect:'Violet survey arcs sweep across a hazy unknown, lighting facts without hiding blind spots.',
+    attach:'Lucid here. This is what I can see.',
+    phases:['listen','sweep','unveil','acknowledge unknown'],
+    visualOnly:true,
+  },
+  {
+    displayName:'Hyperion',id:'hyperion',scene:'power-hyperion',base:'provision',duration:3800,
+    name:'Worldforge',tagline:'Builds a new safe little world',
+    effect:'Amber geometry assembles into a miniature VM capsule under Hyperion’s protective wings.',
+    attach:'Hyperion standing by. Shall I prepare a machine?',
+    phases:['survey','raise wings','assemble capsule','hold for authority'],
+    visualOnly:true,
+  },
+  {
+    displayName:'Seer',id:'seer',scene:'power-seer',base:'inspect',duration:3500,
+    name:'Pathfinder',tagline:'Illuminates the missing path',
+    effect:'Emerald tracer dots follow a route, stop at a gap, and illuminate the missing link.',
+    attach:'Seer here. Show me the trail of evidence.',
+    phases:['scan','trace','find the gap','report'],
+    visualOnly:true,
+  },
+  {
+    displayName:'Sentinel',id:'sentinel',scene:'power-sentinel',base:'guard',duration:3800,
+    name:'Aegis Inferno',tagline:'Shields, intercepts, scorches',
+    effect:'Incoming red threat sparks meet an azure shield. Wings brace, then a fierce blue defensive flame incinerates the abstract intruders.',
+    attach:'Sentinel attached. Perimeter ready.',
+    phases:['detect','intercept','scorch','guard'],
+    visualOnly:true,
+  },
+  {
+    displayName:'Nova',id:'nova',scene:'power-nova',base:'deploy',duration:3200,
+    name:'Greenline',tagline:'Carries work through the pipeline',
+    effect:'Electric-green wingbeats streak past luminous pipeline nodes, without claiming a deploy succeeded.',
+    attach:'Nova ready. Give me the go-ahead.',
+    phases:['check','ignite','dash','await result'],
+    visualOnly:true,
+  },
+  {
+    displayName:'Vulcan',id:'vulcan',scene:'power-vulcan',base:'review',duration:3700,
+    name:'Codeforge',tagline:'Hammers rough code into shape',
+    effect:'A small glowing code fragment meets precise teal sparks, a tiny anvil-strike and a careful inspection.',
+    attach:'Vulcan ready. Let me examine the code.',
+    phases:['inspect','heat','strike','inspect again'],
+    visualOnly:true,
+  },
+]);
+
+export const POWER_BY_NAME=new Map(POWERS.map(p=>[p.displayName,p]));
+// Internal keys exist solely to bridge scene IDs; user-facing identity is displayName.
+export const POWER_BY_ID=new Map(POWERS.map(p=>[p.id,p]));
+export const POWER_BY_SCENE=new Map(POWERS.map(p=>[p.scene,p]));
+export const POWER_SCENE_NAMES=Object.freeze(POWERS.map(p=>p.scene));
+export function powerFor(displayName) {
+  return POWER_BY_NAME.get(displayName)||null;
+}