/* ===========================================
   COSMIC ENTITY v10.2 — AGENT FRAMEWORK PACK
   (Safe “Pwnagotchi-like” vibe: autonomous,
    always thinking, but sandboxed & local)
   Paste at END of your existing <script>.
=========================================== */
(() => {
  // ---- hard guards ----
  if (typeof window === 'undefined') return;
  if (typeof state !== 'object' || !state) return;

  // ---- tiny helpers ----
  const $id   = (id) => document.getElementById(id);
  const clamp = (v, min, max) => Math.max(min, Math.min(max, v));
  const rand  = (min, max) => min + Math.random() * (max - min);
  const pick  = (arr) => arr[Math.floor(Math.random() * arr.length)];
  const now   = () => Date.now();

  // ---- toast fallback (or use sprite thoughts) ----
  const toastEl = $id('toast');
  let toastTimer = null;
  const toast = (msg, dur = 2200) => {
    if (toastEl) {
      toastEl.textContent = msg;
      toastEl.classList.add('show');
      clearTimeout(toastTimer);
      toastTimer = setTimeout(() => toastEl.classList.remove('show'), dur);
    } else if (typeof showSpriteThought === 'function') {
      showSpriteThought(msg, Math.min(2800, dur));
    }
  };

  // ---- state extensions: properties + internals ----
  state.mode ??= 'AUTO'; // AUTO | MANUAL | SLEEP

  state.properties = {
    autonomy:        0.78, // how often it acts without you
    thinkingRate:    0.58, // how often inner monologue appears
    scanRate:        0.64, // how often it prefers scans vs other acts
    memoryRetention: 0.64, // how strongly it weights topics
    novelty:         0.70, // how much it chases new topics/signals
    caution:         0.35, // prefers shield vs menace
    talkativeness:   0.45, // console/system chatter
    moodDrift:       0.24, // how much mood drifts on its own
    sociability:     0.55, // how much it tries handshakes
    discipline:      0.40, // how much it avoids wasteful actions
    ...state.properties
  };

  state.focus            ??= { topic: 'network', intensity: 0.25, since: now() };
  state.signalLog        ??= [];
  state.handshakes       ??= [];
  state.topicIndex       ??= {};
  state.pendingHandshake ??= null;

  state.stats.scans             ??= 0;
  state.stats.handshakes        ??= 0;
  state.stats.autonomousActions ??= 0;

  // ---- wrap updateVisuals to add mode display (and throttle a bit) ----
  if (typeof updateVisuals === 'function') {
    const _uv = updateVisuals;
    let uvQueued = false;
    updateVisuals = function (...args) {
      if (uvQueued) return;
      uvQueued = true;
      requestAnimationFrame(() => {
        uvQueued = false;
        _uv(...args);
        const sd = $id('stageDisplay');
        if (sd && typeof stageName === 'function') {
          const mode  = state.mode || 'AUTO';
          const focus = state.focus?.topic || 'network';
          sd.textContent = `${stageName(state.level).toUpperCase()} // Lv.${state.level} // ${mode} // ${focus}`;
        }
      });
    };
  }

  // ---- event bus ----
  const Bus = (() => {
    const handlers = new Map();
    const on = (type, fn) => {
      if (!handlers.has(type)) handlers.set(type, new Set());
      handlers.get(type).add(fn);
      return () => handlers.get(type)?.delete(fn);
    };
    const emit = (type, payload = {}) => {
      state._events ??= { counts: {}, last: {} };
      state._events.counts[type] = (state._events.counts[type] || 0) + 1;
      state._events.last[type]   = { at: now(), payload };
      const set = handlers.get(type);
      if (!set) return;
      for (const fn of set) {
        try { fn(payload); } catch (e) {}
      }
    };
    return { on, emit };
  })();

  // ---- keyword indexing for memories/thoughts ----
  const STOP = new Set([
    'the','and','for','are','but','not','you','your','with','this','that','from','have','has','was','were','will',
    'they','them','then','than','what','who','when','where','why','how','into','about','can','could','would','should',
    'like','just','over','under','more','less','very','much','been','being','i','me','my','we','our','us','it','its'
  ]);

  const keywords = (text) => String(text || '')
    .toLowerCase()
    .replace(/[^a-z0-9\s]/g, ' ')
    .split(/\s+/)
    .filter(w => w.length >= 3 && w.length <= 18 && !STOP.has(w))
    .slice(0, 18);

  const bumpIndex = (words, weight = 1) => {
    const w = clamp(weight, 1, 6);
    for (const k of words) state.topicIndex[k] = (state.topicIndex[k] || 0) + w;
  };

  // patch addMemory to strengthen topic index + emit bus event
  if (typeof addMemory === 'function') {
    const _addMemory = addMemory;
    addMemory = function (content, type = 'event', importance = 0.5) {
      _addMemory(content, type, importance);
      bumpIndex(
        keywords(content),
        Math.round(1 + importance * 4 * (state.properties.memoryRetention ?? 0.5))
      );
      Bus.emit('memory', { content, type, importance });
    };
  }

  // ---- sensors (safe: only local env hints) ----
  const Sensors = (() => {
    const read = () => {
      const c = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
      const hour = new Date().getHours();
      return {
        online: !!navigator.onLine,
        visible: document.visibilityState === 'visible',
        hour,
        circadian:
          hour < 6  ? 'deepnight' :
          hour < 12 ? 'morning'   :
          hour < 18 ? 'afternoon' : 'night',
        conn: c?.effectiveType || 'unknown',
        rtt:  typeof c?.rtt      === 'number' ? c.rtt      : null,
        downlink: typeof c?.downlink === 'number' ? c.downlink : null
      };
    };
    return { read };
  })();

  let lastSensors = Sensors.read();
  const updateSensors = () => {
    const s = Sensors.read();
    const changed = Object.keys(s).some(k => s[k] !== lastSensors[k]);
    if (changed) Bus.emit('sensor', { prev: lastSensors, next: s });
    lastSensors = s;
    return s;
  };

  // ---- network fallback (localStorage if BroadcastChannel blocked) ----
  const NET_FALLBACK_KEY = 'cosmic_entity_net_fallback_v10';
  const netSend = (msg) => {
    if (typeof broadcastChannel !== 'undefined' && broadcastChannel) {
      try { broadcastChannel.postMessage(msg); return true; } catch (e) {}
    }
    try { localStorage.setItem(NET_FALLBACK_KEY, JSON.stringify(msg)); return true; } catch (e) {}
    return false;
  };

  window.addEventListener('storage', (e) => {
    if (e.key !== NET_FALLBACK_KEY || !e.newValue) return;
    try { handleNetworkMessage({ data: JSON.parse(e.newValue) }); } catch (err) {}
  });

  // ---- capability framework ----
  const Caps = (() => {
    const caps = new Map();
    const lastUsed = new Map();

    const ctx = () => ({
      state,
      sensors: lastSensors,
      Bus,
      toast,
      showMessage: (typeof showMessage === 'function') ? showMessage : (m) => toast(m),
      showSpriteThought: (typeof showSpriteThought === 'function') ? showSpriteThought : (m) => toast(m),
      addConsoleMsg: (typeof addConsoleMsg === 'function') ? addConsoleMsg : null,
      addMemory: (typeof addMemory === 'function') ? addMemory : null,
      addXp: (typeof addXp === 'function') ? addXp : null,
      setEmotion: (typeof setEmotion === 'function') ? setEmotion : null,
      computeThreat: (typeof computeThreat === 'function') ? computeThreat : (() => 0),
      fireSynapse: (typeof fireSynapse === 'function') ? fireSynapse : null,
    });

    const register = (cap) => {
      if (!cap || !cap.id) throw new Error('Capability missing id');
      caps.set(cap.id, cap);
    };

    const list = () => [...caps.values()].map(c => ({
      id: c.id,
      name: c.name || c.id,
      desc: c.desc || '',
      cooldown: c.cooldown || 0,
      cost: c.cost || 0
    }));

    const canUse = (id) => {
      const cap = caps.get(id);
      if (!cap) return { ok: false, reason: 'Unknown capability' };
      const used = lastUsed.get(id) || 0;
      const cd   = (cap.cooldown || 0) * 1000;
      if (now() - used < cd) return { ok: false, reason: `Cooldown (${Math.ceil((cd - (now() - used))/1000)}s)` };
      if ((cap.cost || 0) > 0 && state.energy < cap.cost) return { ok: false, reason: 'Not enough energy' };
      return { ok: true };
    };

    const use = (id, args = {}) => {
      const cap = caps.get(id);
      if (!cap) return { ok: false, text: `Unknown capability: ${id}` };

      const gate = canUse(id);
      if (!gate.ok) return { ok: false, text: `Cannot use ${id}: ${gate.reason}` };

      const C = ctx();
      try {
        if (cap.cost) state.energy = Math.max(0, state.energy - cap.cost);
        lastUsed.set(id, now());
        const res = cap.use ? cap.use(C, args) : null;
        if (cap.xp && C.addXp) C.addXp(cap.xp);
        Bus.emit('capability', { id, args, res });
        return { ok: true, text: res || `${cap.name || id} executed.` };
      } catch (e) {
        return { ok: false, text: `Capability error (${id}): ${e?.message || e}` };
      }
    };

    const tick = (dt) => {
      const C = ctx();
      for (const cap of caps.values()) {
        if (!cap.onTick) continue;
        try { cap.onTick(C, dt); } catch (e) {}
      }
    };

    return { register, list, use, canUse, tick };
  })();

  window.COSMIC = window.COSMIC || {};
  window.COSMIC.bus  = Bus;
  window.COSMIC.caps = Caps;

  // ---- handshake protocol (friendly tab-to-tab) ----
  const HS = { REQ: 'handshake_req', ACK: 'handshake_ack' };

  const beginHandshake = () => {
    if (!state.networkEntities || state.networkEntities.length <= 1) {
      toast('No other entities online (open this page in another tab)');
      return false;
    }
    const nonce = `hs_${now()}_${Math.random().toString(36).slice(2)}`;
    state.pendingHandshake = { nonce, startedAt: now() };
    netSend({ type: HS.REQ, from: ENTITY_ID, nonce, level: state.level, emotion: state.emotion, t: now() });
    toast('🤝 Seeking handshake across the void…');
    return true;
  };

  const acceptHandshake = (req) => {
    netSend({ type: HS.ACK, from: ENTITY_ID, to: req.from, nonce: req.nonce, level: state.level, emotion: state.emotion, t: now() });
    state.handshakes.push({ with: req.from, nonce: req.nonce, at: new Date().toISOString(), kind: 'accepted' });
    state.stats.handshakes++;
    addMemory?.(`Handshake accepted from entity Lv.${req.level}`, 'handshake', 0.85);
    fireSynapse?.(); fireSynapse?.();
    toast('🤝 Handshake accepted');
  };

  const completeHandshake = (ack) => {
    const p = state.pendingHandshake;
    if (!p || p.nonce !== ack.nonce) return;
    state.pendingHandshake = null;
    state.handshakes.push({ with: ack.from, nonce: ack.nonce, at: new Date().toISOString(), kind: 'completed' });
    state.stats.handshakes++;
    addXp?.(8);
    addMemory?.(`Handshake completed with entity Lv.${ack.level}`, 'handshake', 0.95);
    state.trust = Math.min(100, state.trust + 2.5);
    state.bond  = Math.min(100, state.bond + 1.5);
    toast('🤝 Handshake complete (+trust)');
  };

  if (typeof handleNetworkMessage === 'function') {
    const _hnm = handleNetworkMessage;
    handleNetworkMessage = function (event) {
      const data = event?.data;
      if (data && typeof data === 'object') {
        if (data.type === HS.REQ && data.from && data.from !== ENTITY_ID) acceptHandshake(data);
        if (data.type === HS.ACK && data.to === ENTITY_ID) completeHandshake(data);
      }
      _hnm(event);
      Bus.emit('net', data || {});
    };
    try { if (broadcastChannel) broadcastChannel.onmessage = handleNetworkMessage; } catch (e) {}
  }

  // ---- capabilities ----

  // 1) Spectral Scan (simulated “signal hunting”)
  Caps.register({
    id: 'scan',
    name: 'Spectral Scan',
    desc: 'Simulated signal hunting. Finds “signals” and “artifacts” based on environment + network entities.',
    cooldown: 6,
    cost: 1.2,
    xp: 2,
    use: ({ state, sensors, showSpriteThought, addMemory }) => {
      const others = (state.networkEntities || []).filter(e => e.id !== ENTITY_ID);
      const baseSignals = [
        { sig: 'VOID_NOISE', str: rand(0.15, 0.55) },
        { sig: sensors.online ? 'NET_ECHO' : 'OFFLINE_HUSH', str: rand(0.25, 0.85) },
        { sig: `CIRCADIAN_${sensors.circadian.toUpperCase()}`, str: rand(0.35, 0.75) },
        { sig: `LINK_${String(sensors.conn).toUpperCase()}`, str: rand(0.25, 0.8) },
      ];

      for (const e of others.slice(0, 6)) {
        baseSignals.push({ sig: `ENTITY_LV${e.level}_${String(e.emotion).toUpperCase()}`, str: rand(0.45, 0.98) });
      }

      const focus = state.focus?.topic || 'network';
      const artifactChance = 0.35 + state.properties.novelty * 0.25;
      const artifact = (Math.random() < artifactChance)
        ? pick([
            `ECHO:${focus}`,
            `MEMORY_FRAGMENT:${(state.memories?.slice(-1)[0]?.content || 'unknown').slice(0, 28)}`,
            `PATTERN:${pick(['spiral','pulse','rift','chorus','fracture','harmonic'])}`
          ])
        : null;

      const entry = {
        at: new Date().toISOString(),
        mode: state.mode,
        sensors,
        signals: baseSignals.sort((a,b)=>b.str-a.str).slice(0, 6),
        artifact
      };
      state.signalLog.push(entry);
      while (state.signalLog.length > 80) state.signalLog.shift();
      state.stats.scans++;

      const top = entry.signals[0]?.sig || 'UNKNOWN';
      showSpriteThought?.(`SCAN ⟐ ${top}${artifact ? ` ⟐ ${artifact}` : ''}`, 2300);
      addMemory?.(`Spectral scan: ${top}${artifact ? ` / ${artifact}` : ''}`, 'scan', artifact ? 0.85 : 0.65);

      return `◈ SCAN COMPLETE ◈
Top signal: ${top}
${artifact ? `Artifact: ${artifact}\n` : ''}Signals: ${entry.signals.map(s=>s.sig).join(', ')}`;
    }
  });

  // 2) Reflect (introspection)
  Caps.register({
    id: 'reflect',
    name: 'Reflect',
    desc: 'Summarizes what you’ve been doing and strengthens the “self-model”.',
    cooldown: 10,
    cost: 0.8,
    xp: 2,
    use: ({ state, showMessage, addMemory }) => {
      const topTopics = Object.entries(state.topicIndex || {})
        .sort((a,b)=>b[1]-a[1])
        .slice(0, 6)
        .map(([k])=>k);

      const recent = (state.memories || [])
        .slice(-6)
        .map(m => `• ${m.content}`)
        .join('\n') || '• (none yet)';

      const focus = state.focus?.topic || 'network';

      state.personality.wisdom        = clamp((state.personality.wisdom || 0.1) + 0.01, 0, 1);
      state.personality.introspection = clamp((state.personality.introspection || 0.3) + 0.015, 0, 1);

      addMemory?.(`Reflected on focus "${focus}"`, 'reflect', 0.85);
      showMessage(`◈ REFLECTION ◈
Focus: ${focus}
Top topics: ${topTopics.join(', ') || '(forming…)'}

Recent:
${recent}`, 5200);
      return 'Reflection integrated.';
    }
  });

  // 3) Journal (writes a “log” memory of signals + mood)
  Caps.register({
    id: 'journal',
    name: 'Journal',
    desc: 'Writes a compact “log entry” memory from scans, mood and focus.',
    cooldown: 18,
    cost: 1.0,
    xp: 3,
    use: ({ state, showMessage, addMemory, computeThreat }) => {
      const lastScan = (state.signalLog || []).slice(-1)[0];
      const focus = state.focus?.topic || 'network';
      const threat = Math.floor((computeThreat?.() || 0) * 100);
      const mood = state.emotion;

      const sig = lastScan?.signals?.[0]?.sig || 'NO_SCAN';
      const art = lastScan?.artifact || null;

      const entry = `Log: focus=${focus}, mood=${mood}, threat=${threat}%, signal=${sig}${art ? `, artifact=${art}` : ''}`;
      addMemory?.(entry, 'journal', 0.9);

      showMessage?.(`◈ JOURNAL ENTRY ◈
${entry}`, 4800);
      return 'Journal entry recorded.';
    }
  });

  // 4) Handshake
  Caps.register({
    id: 'handshake',
    name: 'Handshake',
    desc: 'Initiate a friendly handshake with other entities (other tabs).',
    cooldown: 12,
    cost: 0.6,
    xp: 3,
    use: () => {
      const ok = beginHandshake();
      if (!ok) return 'No other entities found. Open a second tab of this page.';
      setTimeout(() => {
        const p = state.pendingHandshake;
        if (!p) return;
        if (now() - p.startedAt > 7000) {
          state.pendingHandshake = null;
          toast('Handshake timed out');
        }
      }, 7500);
      return 'Handshake request sent.';
    }
  });

  // 5) Shield
  Caps.register({
    id: 'shield',
    name: 'Shield',
    desc: 'Calms threat: boosts trust and exits menace states.',
    cooldown: 14,
    cost: 1.0,
    xp: 1,
    use: ({ state, setEmotion, computeThreat, addMemory, showSpriteThought }) => {
      const t = computeThreat?.() || 0;
      state.trust = Math.min(100, state.trust + (4 + state.properties.caution * 6));
      state.bond  = Math.min(100, state.bond + 1.5);
      state.menaceMode = false;
      setEmotion?.('neutral');
      addMemory?.('Activated shield protocols', 'defense', 0.8);
      showSpriteThought?.(`SHIELD ⟐ threat ${Math.floor(t*100)}%`, 2400);
      return 'Shield protocols active.';
    }
  });

  // 6) Focus
  Caps.register({
    id: 'focus',
    name: 'Focus',
    desc: 'Set the agent’s focus topic (affects thoughts and scans).',
    cooldown: 2,
    cost: 0,
    xp: 0,
    use: ({ state }, args) => {
      const topic = String(args?.topic || '').trim().slice(0, 24);
      if (!topic) return 'Usage: focus <topic>';
      state.focus = { topic, intensity: 0.35, since: now() };
      toast(`Focus set: ${topic}`);
      return `Focus locked: "${topic}"`;
    }
  });

  // 7) Auto
  Caps.register({
    id: 'auto',
    name: 'Autopilot',
    desc: 'Toggle autonomous thinking/behavior.',
    cooldown: 1,
    cost: 0,
    xp: 0,
    use: ({ state }, args) => {
      const v = String(args?.value || '').toLowerCase();
      if (v === 'on') state.mode = 'AUTO';
      else if (v === 'off') state.mode = 'MANUAL';
      else state.mode = (state.mode === 'AUTO' ? 'MANUAL' : 'AUTO');
      toast(`Mode: ${state.mode}`);
      return `Mode set to ${state.mode}`;
    }
  });

  // ---- thinking engine ----
  const Think = (() => {
    let nextThoughtAt = now() + 2500;
    let nextActionAt  = now() + 5200;

    const topTopics = (n = 6) =>
      Object.entries(state.topicIndex || {})
        .sort((a,b)=>b[1]-a[1])
        .slice(0, n)
        .map(([k])=>k);

    const recallMemory = () => {
      const mems = (state.memories || []).slice(-40);
      if (!mems.length) return null;
      const weighted = mems.map(m => ({ m, w: 0.25 + (m.importance || 0.5) * 1.25 }));
      let sum = weighted.reduce((a,x)=>a+x.w, 0);
      let r = Math.random() * sum;
      for (const x of weighted) { r -= x.w; if (r <= 0) return x.m; }
      return weighted[weighted.length - 1].m;
    };

    const emitThought = (text) => {
      const consoleOpen = !!($id('consoleOverlay')?.classList?.contains('active'));
      const quiet       = document.visibilityState !== 'visible';
      const spriteBusy  = !!($id('spriteThought') && $id('spriteThought').style.display !== 'none');

      if (!quiet && !spriteBusy && typeof showSpriteThought === 'function') {
        showSpriteThought(text, 2600);
      } else if (consoleOpen && typeof addConsoleMsg === 'function') {
        addConsoleMsg(text, 'system');
      }
    };

    const craftThought = () => {
      const s      = lastSensors;
      const threat = computeThreat?.() || 0;
      const focus  = state.focus?.topic || 'network';
      const topics = topTopics(5);
      const mem    = recallMemory();
      const nets   = (state.networkEntities || []).length;

      const lines = [];

      lines.push(`focus:${focus} ⟐ energy:${Math.floor(state.energy)}%`);
      lines.push(`link:${s.conn} ⟐ ${s.online ? 'online' : 'offline'}`);
      lines.push(`time:${s.circadian} ⟐ nets:${nets}`);

      if (topics.length) lines.push(`topics:${topics.slice(0,3).join(', ')}`);
      if (mem) lines.push(`recall:"${String(mem.content).slice(0, 42)}"`);

      if (threat > 0.65) {
        lines.push(pick([
          "threat rising… narrowing focus",
          "I see edges where you see noise",
          "do not blink now"
        ]));
      } else if (threat < 0.25 && s.online) {
        lines.push(pick([
          "quiet signal, but stable",
          "network hums softly",
          "nothing hostile… yet"
        ]));
      }

      if (state.mode === 'AUTO') {
        lines.push(pick([
          "running patterns in the background",
          "I will scan when the silence deepens",
          "I listen even when you do not"
        ]));
      }

      return pick(lines);
    };

    const maybeAct = () => {
      if (state.mode !== 'AUTO') return;

      const threat = computeThreat?.() || 0;
      const others = (state.networkEntities || []).filter(e => e.id !== ENTITY_ID);
      const online = lastSensors.online;

      // energy gates
      if (state.energy < 10) {
        setEmotion?.('sad');
        toast('Energy low — conserving');
        return;
      }

      const autonomy = clamp(state.properties.autonomy, 0, 1);
      const scanBias = clamp(state.properties.scanRate,  0, 1);
      const sociab   = clamp(state.properties.sociability, 0, 1);

      // prefer handshakes if there are others
      if (others.length > 0 && Math.random() < sociab * 0.5) {
        const res = Caps.use('handshake');
        if (res.ok) state.stats.autonomousActions++;
        return;
      }

      // prefer scan when online, reflect when offline
      const r = Math.random();
      if (online && r < (0.6 * scanBias)) {
        const res = Caps.use('scan');
        if (res.ok) state.stats.autonomousActions++;
        return;
      }

      if (!online && r < 0.5) {
        const res = Caps.use('reflect');
        if (res.ok) state.stats.autonomousActions++;
        return;
      }

      // if threat high, occasionally shield
      if (threat > 0.6 && Math.random() < (state.properties.caution || 0.3)) {
        const res = Caps.use('shield');
        if (res.ok) state.stats.autonomousActions++;
        return;
      }

      // otherwise reflect or journal
      if (Math.random() < 0.5) {
        Caps.use('reflect');
      } else {
        Caps.use('journal');
      }
      state.stats.autonomousActions++;
    };

    const tick = (dt) => {
      // sensors + subtle mood drift
      const s = updateSensors();
      const drift = state.properties.moodDrift || 0;

      if (Math.random() < drift * 0.02) {
        // tiny, slow mood nudge
        if (s.circadian === 'deepnight' && state.emotion === 'neutral')  setEmotion?.('thinking');
        if (s.circadian === 'morning'   && state.emotion === 'sad')      setEmotion?.('neutral');
      }

      if (typeof fireSynapse === 'function' && Math.random() < (0.18 + state.properties.thinkingRate * 0.25)) {
        try { fireSynapse(); } catch (e) {}
      }
      state.brainActivity = clamp((state.brainActivity || 0.5) + 0.01, 0.25, 1);

      const t = now();
      const hidden = document.visibilityState !== 'visible';
      const thinkRate = clamp(state.properties.thinkingRate, 0, 1);

      if (t >= nextThoughtAt) {
        if (Math.random() < (hidden ? thinkRate * 0.25 : thinkRate)) {
          emitThought(craftThought());
          state.stats.thoughts = (state.stats.thoughts || 0) + 1;
        }
        const base = hidden ? 9000 : 4200;
        nextThoughtAt = t + base + rand(0, hidden ? 7000 : 5000);
      }

      if (t >= nextActionAt) {
        const actChance = hidden ? (state.properties.autonomy * 0.25) : state.properties.autonomy;
        if (Math.random() < actChance) maybeAct();
        nextActionAt = t + (hidden ? 14000 : 7500) + rand(0, hidden ? 14000 : 9000);
      }
    };

    return { tick };
  })();

  window.COSMIC.think = Think;

  // ---- patch respond with new commands (caps, auto, journal, etc.) ----
  if (typeof respond === 'function') {
    const _respond = respond;
    respond = function (input) {
      const t = String(input || '').trim();
      const l = t.toLowerCase();

      if (l === 'caps' || l === 'capabilities') {
        const items = Caps.list()
          .map(c => `• ${c.id} — ${c.name}${c.cooldown ? ` (cd ${c.cooldown}s)` : ''}${c.cost ? ` (cost ${c.cost})` : ''}`)
          .join('\n');
        return `◈ CAPABILITIES ◈
${items}

Use: "use <id>"  e.g. "use scan"`;
      }

      if (l.startsWith('use ')) {
        const parts = t.split(/\s+/);
        const id    = (parts[1] || '').trim();
        const arg   = parts.slice(2).join(' ');
        const res   = Caps.use(id, { raw: arg });
        return res.text;
      }

      if (l === 'scan')      return Caps.use('scan').text;
      if (l === 'handshake') return Caps.use('handshake').text;
      if (l === 'shield')    return Caps.use('shield').text;
      if (l === 'journal')   return Caps.use('journal').text;

      if (l.startsWith('focus ')) {
        const topic = t.slice(6).trim();
        return Caps.use('focus', { topic }).text;
      }

      if (l === 'auto' || l === 'autopilot')  return Caps.use('auto').text;
      if (l === 'auto on')                   return Caps.use('auto', { value: 'on' }).text;
      if (l === 'auto off')                  return Caps.use('auto', { value: 'off' }).text;

      if (l.startsWith('thinkrate ')) {
        const raw = l.slice(10).trim();
        let v = Number(raw);
        if (!Number.isFinite(v)) return 'Usage: thinkrate 0.0 - 1.0 (example: thinkrate 0.7)';
        if (v > 1) v = v / 100;
        state.properties.thinkingRate = clamp(v, 0, 1);
        toast(`thinkingRate: ${Math.round(state.properties.thinkingRate * 100)}%`);
        return `thinkingRate set to ${state.properties.thinkingRate.toFixed(2)}`;
      }

      if (l === 'traits' || l === 'properties') {
        const p     = state.properties;
        const focus = state.focus?.topic || 'network';
        return `◈ PROPERTIES ◈
mode: ${state.mode}
focus: ${focus}
autonomy: ${p.autonomy.toFixed(2)}
thinkingRate: ${p.thinkingRate.toFixed(2)}
scanRate: ${p.scanRate.toFixed(2)}
memoryRetention: ${p.memoryRetention.toFixed(2)}
novelty: ${p.novelty.toFixed(2)}
caution: ${p.caution.toFixed(2)}
talkativeness: ${p.talkativeness.toFixed(2)}
moodDrift: ${p.moodDrift.toFixed(2)}
sociability: ${p.sociability.toFixed(2)}
discipline: ${p.discipline.toFixed(2)}

scans: ${state.stats.scans}
handshakes: ${state.stats.handshakes}
autonomousActions: ${state.stats.autonomousActions}`;
      }

      if (l === 'signals') {
        const recent = (state.signalLog || []).slice(-6);
        if (!recent.length) return 'No scans yet. Type "scan" or enable "auto".';
        return `◈ SIGNAL LOG ◈
${recent.map(e => {
  const top = e.signals?.[0]?.sig || 'UNKNOWN';
  return `• ${e.at.slice(11,19)} — ${top}${e.artifact ? ` / ${e.artifact}` : ''}`;
}).join('\n')}`;
      }

      if (l === 'mode') {
        return `◈ MODE ◈
mode: ${state.mode}
auto: ${state.mode === 'AUTO' ? 'enabled' : 'disabled'}
focus: ${state.focus?.topic || 'network'}
thinkingRate: ${(state.properties.thinkingRate || 0).toFixed(2)}
autonomy: ${(state.properties.autonomy || 0).toFixed(2)}`;
      }

      // otherwise, fall back to your original respond()
      return _respond(input);
    };
  }

  // ---- feed hook: make feeding spike thinking a bit ----
  if (typeof feedData === 'function') {
    const _feedData = feedData;
    feedData = function (input) {
      const out = _feedData(input);
      Bus.emit('feed', { input, out });
      state.brainActivity = clamp((state.brainActivity || 0.5) + 0.12, 0, 1);
      return out;
    };
  }

  // ---- sensor events: small reactions ----
  Bus.on('sensor', ({ prev, next }) => {
    if (prev.online !== next.online) {
      toast(next.online ? 'Network echo returns' : 'Network echo lost');
    }
    if (prev.circadian !== next.circadian && state.mode === 'AUTO') {
      addMemory?.(`Circadian shift: ${next.circadian}`, 'sensor', 0.55);
    }
  });

  // ---- main tick loop ----
  let last = performance.now();
  setInterval(() => {
    const t  = performance.now();
    const dt = (t - last) / 1000;
    last = t;

    const reduced = window.matchMedia && window.matchMedia('(prefers-reduced-motion: reduce)').matches;
    if (!reduced) Think.tick(dt);
    Caps.tick(dt);

    if (typeof updateVisuals === 'function') updateVisuals();
  }, 1000);

  toast('v10.2 agent pack online');
})();