orchestrix-yuri 2.7.0 → 3.0.1

package/bin/status.js

@@ -4,12 +4,11 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { execSync } = require('child_process');
 
 const PID_FILE = path.join(os.homedir(), '.yuri', 'gateway.pid');
+const SESSION_FILE = path.join(os.homedir(), '.yuri', 'gateway-session.json');
 
 function status() {
-  // Check PID
   let pid = null;
   let running = false;
 
@@ -23,32 +22,37 @@ function status() {
     }
   }
 
-  // Check tmux session
-  let tmuxAlive = false;
-  try {
-    execSync('tmux has-session -t yuri-gateway 2>/dev/null');
-    tmuxAlive = true;
-  } catch {
-    tmuxAlive = false;
+  // Check session
+  let sessionInfo = 'none';
+  if (fs.existsSync(SESSION_FILE)) {
+    try {
+      const s = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8'));
+      const age = Date.now() - new Date(s.savedAt).getTime();
+      if (age < 24 * 3600_000) {
+        sessionInfo = `${s.sessionId.slice(0, 8)}... (${s.messageCount || 0} messages)`;
+      } else {
+        sessionInfo = 'expired';
+      }
+    } catch { /* ignore */ }
   }
 
-  console.log('');
-  console.log('  Yuri Gateway Status');
-  console.log('  ───────────────────');
-  console.log(`  Gateway process:  ${running ? `\x1b[32mrunning\x1b[0m (PID ${pid})` : '\x1b[90mnot running\x1b[0m'}`);
-  console.log(`  tmux session:     ${tmuxAlive ? '\x1b[32myuri-gateway (active)\x1b[0m' : '\x1b[90mnone\x1b[0m'}`);
-
   // Check config
   const configPath = path.join(os.homedir(), '.yuri', 'config', 'channels.yaml');
+  let tokenStatus = '\x1b[90mnot set\x1b[0m';
   if (fs.existsSync(configPath)) {
     const content = fs.readFileSync(configPath, 'utf8');
-    const hasToken = /token:\s*".+"/.test(content) || /token:\s*'.+'/.test(content);
-    console.log(`  Telegram token:   ${hasToken ? '\x1b[32mconfigured\x1b[0m' : '\x1b[90mnot set\x1b[0m'}`);
-  } else {
-    console.log('  Config:           \x1b[90mnot found\x1b[0m');
+    if (/token:\s*".+"/.test(content) || /token:\s*'.+'/.test(content)) {
+      tokenStatus = '\x1b[32mconfigured\x1b[0m';
+    }
   }
 
   console.log('');
+  console.log('  Yuri Gateway Status');
+  console.log('  ───────────────────');
+  console.log(`  Gateway process:  ${running ? `\x1b[32mrunning\x1b[0m (PID ${pid})` : '\x1b[90mnot running\x1b[0m'}`);
+  console.log(`  Claude session:   ${sessionInfo}`);
+  console.log(`  Telegram token:   ${tokenStatus}`);
+  console.log('');
 }
 
 status();

package/bin/stop.js

@@ -4,8 +4,6 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { execSync } = require('child_process');
-
 const PID_FILE = path.join(os.homedir(), '.yuri', 'gateway.pid');
 
 function stop() {
@@ -22,7 +20,6 @@ function stop() {
   } catch {
     console.log(`  Gateway PID ${pid} is not running. Cleaning up stale PID file.`);
     fs.unlinkSync(PID_FILE);
-    cleanupTmux();
     process.exit(0);
   }
 
@@ -45,18 +42,9 @@ function stop() {
     } catch {
       // Dead, good
     }
-    cleanupTmux();
     try { fs.unlinkSync(PID_FILE); } catch {}
     console.log('  ✅ Gateway stopped.');
   }, 2000);
 }
 
-function cleanupTmux() {
-  try {
-    execSync('tmux kill-session -t yuri-gateway 2>/dev/null');
-  } catch {
-    // no session to kill
-  }
-}
-
 stop();

package/lib/gateway/config.js

@@ -19,13 +19,7 @@ const DEFAULTS = {
   },
   engine: {
     skill: 'yuri',
-    tmux_session: 'yuri-gateway',
-    startup_timeout: 60000,       // ms to wait for Claude Code to initialize
-    poll_interval: 2000,          // ms between capture-pane polls
-    stable_count: 3,              // consecutive stable polls before declaring done
-    max_retries: 3,               // session restart retries before error
     timeout: 300000,              // per-message timeout (5 min)
-    history_limit: 10000,         // tmux scrollback lines
     autocompact_pct: 80,          // trigger auto-compact at this % (default 95%)
     compact_every: 50,            // proactive /compact after N messages
   },

package/lib/gateway/engine/claude-sdk.js

@@ -0,0 +1,359 @@
+'use strict';
+
+const { execFile, execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const yaml = require('js-yaml');
+
+const YURI_GLOBAL = path.join(os.homedir(), '.yuri');
+const SESSION_FILE = path.join(YURI_GLOBAL, 'gateway-session.json');
+const { log } = require('../log');
+
+// ── Shared Utilities ───────────────────────────────────────────────────────────
+
+function loadL1Context() {
+  const files = [
+    { label: 'Yuri Identity', path: path.join(YURI_GLOBAL, 'self.yaml') },
+    { label: 'Boss Profile', path: path.join(YURI_GLOBAL, 'boss', 'profile.yaml') },
+    { label: 'Boss Preferences', path: path.join(YURI_GLOBAL, 'boss', 'preferences.yaml') },
+    { label: 'Portfolio Registry', path: path.join(YURI_GLOBAL, 'portfolio', 'registry.yaml') },
+    { label: 'Global Focus', path: path.join(YURI_GLOBAL, 'focus.yaml') },
+  ];
+
+  const sections = [];
+  for (const f of files) {
+    if (fs.existsSync(f.path)) {
+      const content = fs.readFileSync(f.path, 'utf8').trim();
+      if (content) {
+        sections.push(`### ${f.label}\n\`\`\`yaml\n${content}\n\`\`\``);
+      }
+    }
+  }
+
+  return sections.length > 0
+    ? `## Yuri Global Memory (L1 — pre-loaded)\n\n${sections.join('\n\n')}`
+    : '';
+}
+
+function resolveProjectRoot() {
+  const registryPath = path.join(YURI_GLOBAL, 'portfolio', 'registry.yaml');
+  if (!fs.existsSync(registryPath)) return null;
+
+  const registry = yaml.load(fs.readFileSync(registryPath, 'utf8')) || {};
+  const projects = registry.projects || [];
+  const active = projects.filter((p) => p.status === 'active');
+
+  if (active.length === 0) return null;
+
+  const focusPath = path.join(YURI_GLOBAL, 'focus.yaml');
+  if (fs.existsSync(focusPath)) {
+    const focus = yaml.load(fs.readFileSync(focusPath, 'utf8')) || {};
+    if (focus.active_project) {
+      const match = active.find((p) => p.id === focus.active_project);
+      if (match && fs.existsSync(match.root)) return match.root;
+    }
+  }
+
+  if (active[0] && fs.existsSync(active[0].root)) return active[0].root;
+  return null;
+}
+
+function findClaudeBinary() {
+  try {
+    const resolved = execSync('zsh -lc "which claude" 2>/dev/null', { encoding: 'utf8' }).trim();
+    if (resolved && fs.existsSync(resolved)) return resolved;
+  } catch { /* fall through */ }
+
+  const candidates = [
+    '/usr/local/bin/claude',
+    '/opt/homebrew/bin/claude',
+    path.join(os.homedir(), '.npm-global', 'bin', 'claude'),
+    path.join(os.homedir(), '.local', 'bin', 'claude'),
+    path.join(os.homedir(), '.claude', 'bin', 'claude'),
+  ];
+
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return 'claude';
+}
+
+let _claudeBinary = null;
+function getClaudeBinary() {
+  if (!_claudeBinary) {
+    _claudeBinary = findClaudeBinary();
+    log.engine(`Using binary: ${_claudeBinary}`);
+  }
+  return _claudeBinary;
+}
+
+// ── State ──────────────────────────────────────────────────────────────────────
+
+let _sessionId = null;
+let _messageCount = 0;
+let _messageQueue = Promise.resolve();
+
+// ── System Prompt ──────────────────────────────────────────────────────────────
+
+const SKILL_PATH = path.join(os.homedir(), '.claude', 'skills', 'yuri', 'SKILL.md');
+
+const CHANNEL_MODE_INSTRUCTIONS = [
+  '## Channel Mode (Yuri Gateway)',
+  '',
+  'You are responding via a messaging channel (Telegram/Feishu), not a terminal.',
+  '- Keep responses concise and mobile-friendly.',
+  '- Use markdown formatting sparingly (Telegram supports basic markdown).',
+  '- If you need to perform operations, do so and report the result.',
+  '- At the end of your response, if you observed any memory-worthy signals',
+  '  (user preferences, priority changes, tech lessons, corrections),',
+  '  write them to ~/.yuri/inbox.jsonl.',
+  '- Update ~/.yuri/focus.yaml and the project\'s focus.yaml after any operation.',
+].join('\n');
+
+/**
+ * Build the system prompt that gives Claude the Yuri identity.
+ *
+ * Layers (in order):
+ *   1. SKILL.md — Yuri persona, commands, activation protocol, behavior rules
+ *   2. L1 context — global memory (self.yaml, boss profile, portfolio, focus)
+ *   3. Channel mode — Telegram-specific response formatting rules
+ *
+ * In terminal mode, SKILL.md is loaded automatically by Claude Code's /yuri skill.
+ * In gateway mode (-p), we must inject it manually via --system-prompt.
+ */
+function buildSystemPrompt() {
+  const parts = [];
+
+  // Layer 1: Yuri skill definition (persona + commands + behavior)
+  if (fs.existsSync(SKILL_PATH)) {
+    let skill = fs.readFileSync(SKILL_PATH, 'utf8');
+    // Strip YAML frontmatter (---...---) — it's metadata for Claude Code, not prompt content
+    skill = skill.replace(/^---[\s\S]*?---\s*\n/, '');
+    parts.push(skill.trim());
+  } else {
+    // Fallback if skill not installed
+    parts.push(
+      '# Yuri — Meta-Orchestrator\n\n' +
+      'You are **Yuri**, a Meta-Orchestrator and Technical Chief of Staff.\n' +
+      'You manage the user\'s entire project portfolio via Orchestrix agents.\n' +
+      'NEVER say you are Claude or Claude Code. You are Yuri.'
+    );
+  }
+
+  // Layer 2: L1 global memory
+  const l1 = loadL1Context();
+  if (l1) parts.push(l1);
+
+  // Layer 3: Channel mode instructions
+  parts.push(CHANNEL_MODE_INSTRUCTIONS);
+
+  return parts.join('\n\n---\n\n');
+}
+
+// ── Session Persistence ────────────────────────────────────────────────────────
+
+// Session format version — increment when system prompt changes significantly
+// to force fresh session creation instead of resuming with stale identity.
+const SESSION_VERSION = 2;
+
+function saveSessionState() {
+  try {
+    const dir = path.dirname(SESSION_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(SESSION_FILE, JSON.stringify({
+      version: SESSION_VERSION,
+      sessionId: _sessionId,
+      messageCount: _messageCount,
+      savedAt: new Date().toISOString(),
+    }));
+  } catch { /* best effort */ }
+}
+
+function loadSessionState() {
+  if (!fs.existsSync(SESSION_FILE)) return null;
+  try {
+    const state = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8'));
+    // Reject: wrong version (system prompt changed), or expired (>24h)
+    if (state.version !== SESSION_VERSION) return null;
+    const age = Date.now() - new Date(state.savedAt).getTime();
+    if (age > 24 * 3600_000) return null;
+    return state;
+  } catch { return null; }
+}
+
+function clearSessionState() {
+  _sessionId = null;
+  _messageCount = 0;
+  try { fs.unlinkSync(SESSION_FILE); } catch { /* ok */ }
+}
+
+// ── Core: Run Claude CLI ───────────────────────────────────────────────────────
+
+/**
+ * Execute `claude -p --output-format json` and return parsed result.
+ */
+function runClaude(args, cwd, timeout) {
+  return new Promise((resolve) => {
+    const binary = getClaudeBinary();
+
+    log.engine(`Calling: claude ${args.slice(0, 4).join(' ')}... (cwd: ${cwd})`);
+
+    const proc = execFile(binary, args, {
+      cwd,
+      timeout: timeout || 300000,
+      maxBuffer: 10 * 1024 * 1024, // 10MB
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: '80',
+      },
+    }, (err, stdout, stderr) => {
+      if (err && err.killed) {
+        log.warn('Claude CLI timed out');
+        return resolve({ reply: '⏱ Response timed out.', raw: '' });
+      }
+      if (err) {
+        log.error(`Claude CLI error: ${err.message}`);
+        if (stderr) log.info(`stderr: ${stderr.slice(0, 200)}`);
+        return resolve({ reply: `❌ Claude CLI error: ${err.message}`, raw: stderr });
+      }
+
+      try {
+        const result = JSON.parse(stdout);
+        if (result.is_error) {
+          return resolve({ reply: `❌ ${result.result || 'Unknown error'}`, raw: stdout });
+        }
+
+        const duration = result.duration_ms ? `${(result.duration_ms / 1000).toFixed(1)}s` : '?';
+        const cost = result.total_cost_usd ? `$${result.total_cost_usd.toFixed(4)}` : '';
+        log.engine(`Done in ${duration} ${cost}`);
+
+        resolve({
+          reply: result.result || '(empty response)',
+          raw: stdout,
+          sessionId: result.session_id,
+          cost: result.total_cost_usd,
+          duration: result.duration_ms,
+        });
+      } catch (parseErr) {
+        // Non-JSON output — return raw
+        log.warn(`Failed to parse JSON response: ${parseErr.message}`);
+        resolve({ reply: stdout.trim() || '(empty response)', raw: stdout });
+      }
+    });
+  });
+}
+
+// ── Public API ─────────────────────────────────────────────────────────────────
+
+/**
+ * Send a message to Claude Code via `claude -p --output-format json`.
+ * First call creates a session with --system-prompt.
+ * Subsequent calls use --resume SESSION_ID for context continuity.
+ */
+async function callClaude(opts) {
+  const { prompt, engineConfig, timeout } = opts;
+  const cwd = resolveProjectRoot() || os.homedir();
+  const callTimeout = timeout || engineConfig.timeout || 300000;
+
+  return new Promise((resolve, reject) => {
+    _messageQueue = _messageQueue.then(async () => {
+      try {
+        // Try to restore session from disk on first call
+        if (!_sessionId) {
+          const saved = loadSessionState();
+          if (saved) {
+            log.engine(`Restoring session ${saved.sessionId.slice(0, 8)}...`);
+            _sessionId = saved.sessionId;
+            _messageCount = saved.messageCount || 0;
+          }
+        }
+
+        // Proactive compact
+        const compactEvery = (engineConfig && engineConfig.compact_every) || 50;
+        if (_messageCount > 0 && _messageCount % compactEvery === 0 && _sessionId) {
+          log.engine('Proactive /compact...');
+          await runClaude([
+            '-p', '--output-format', 'json',
+            '--dangerously-skip-permissions',
+            '--resume', _sessionId,
+            '/compact focus on the most recent user conversation',
+          ], cwd, 120000);
+          log.engine('/compact done');
+        }
+
+        // Build args
+        const args = ['-p', '--output-format', 'json', '--dangerously-skip-permissions'];
+
+        if (_sessionId) {
+          args.push('--resume', _sessionId);
+        } else {
+          args.push('--system-prompt', buildSystemPrompt());
+        }
+
+        args.push(prompt);
+
+        // Execute
+        const result = await runClaude(args, cwd, callTimeout);
+
+        // Store session ID for subsequent calls
+        if (result.sessionId) {
+          _sessionId = result.sessionId;
+        }
+
+        _messageCount++;
+        saveSessionState();
+
+        // If --resume failed (session expired), retry with fresh session
+        if (result.reply && result.reply.includes('❌') && _sessionId) {
+          log.warn('Session may have expired, retrying with fresh session...');
+          clearSessionState();
+
+          const freshArgs = [
+            '-p', '--output-format', 'json', '--dangerously-skip-permissions',
+            '--system-prompt', buildSystemPrompt(),
+            prompt,
+          ];
+          const freshResult = await runClaude(freshArgs, cwd, callTimeout);
+          if (freshResult.sessionId) {
+            _sessionId = freshResult.sessionId;
+            _messageCount = 1;
+            saveSessionState();
+          }
+          return resolve(freshResult);
+        }
+
+        resolve(result);
+      } catch (err) {
+        log.error(`callClaude error: ${err.message}`);
+        resolve({ reply: `❌ Engine error: ${err.message}`, raw: '' });
+      }
+    }).catch(reject);
+  });
+}
+
+/**
+ * Compose prompt — just returns the raw user message.
+ * L1 context and channel instructions are handled by --system-prompt.
+ */
+function composePrompt(userMessage, _chatHistory) {
+  return userMessage;
+}
+
+/**
+ * Destroy session state. Called on gateway shutdown.
+ */
+function destroySession() {
+  // Don't clear session file — allow restart to resume
+  log.engine('Gateway shutting down (session preserved for restart)');
+}
+
+module.exports = {
+  callClaude,
+  composePrompt,
+  loadL1Context,
+  resolveProjectRoot,
+  findClaudeBinary,
+  destroySession,
+};

package/lib/gateway/log.js

@@ -26,7 +26,7 @@ const log = {
   // Tagged module loggers
   gateway: (msg) => console.log(`${tag(c.magenta, 'gateway')} ${msg}`),
   router:  (msg) => console.log(`${tag(c.blue, 'router')} ${msg}`),
-  tmux:    (msg) => console.log(`${tag(c.cyan, 'tmux')} ${msg}`),
+  engine:  (msg) => console.log(`${tag(c.cyan, 'engine')} ${msg}`),
   telegram:(msg) => console.log(`${tag(c.green, 'telegram')} ${msg}`),
 
   // Levels

package/lib/gateway/router.js

@@ -7,7 +7,7 @@ const yaml = require('js-yaml');
 
 const { ChatHistory } = require('./history');
 const { OwnerBinding } = require('./binding');
-const engine = require('./engine/claude-tmux');
+const engine = require('./engine/claude-sdk');
 const { log } = require('./log');
 
 const YURI_GLOBAL = path.join(os.homedir(), '.yuri');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchestrix-yuri",
-  "version": "2.7.0",
+  "version": "3.0.1",
   "description": "Yuri — Meta-Orchestrator for Orchestrix. Drive your entire project lifecycle with natural language.",
   "main": "lib/installer.js",
   "bin": {

package/lib/gateway/engine/claude-tmux.js

@@ -1,684 +0,0 @@
-'use strict';
-
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const crypto = require('crypto');
-const yaml = require('js-yaml');
-
-const YURI_GLOBAL = path.join(os.homedir(), '.yuri');
-const { log } = require('../log');
-
-// ── Shared Utilities (formerly in claude-cli.js) ───────────────────────────────
-
-/**
- * Load L1 (global context) files and compose them into a context block.
- * Injected into the prompt so Claude does not need to "remember" to read them.
- */
-function loadL1Context() {
-  const files = [
-    { label: 'Yuri Identity', path: path.join(YURI_GLOBAL, 'self.yaml') },
-    { label: 'Boss Profile', path: path.join(YURI_GLOBAL, 'boss', 'profile.yaml') },
-    { label: 'Boss Preferences', path: path.join(YURI_GLOBAL, 'boss', 'preferences.yaml') },
-    { label: 'Portfolio Registry', path: path.join(YURI_GLOBAL, 'portfolio', 'registry.yaml') },
-    { label: 'Global Focus', path: path.join(YURI_GLOBAL, 'focus.yaml') },
-  ];
-
-  const sections = [];
-  for (const f of files) {
-    if (fs.existsSync(f.path)) {
-      const content = fs.readFileSync(f.path, 'utf8').trim();
-      if (content) {
-        sections.push(`### ${f.label}\n\`\`\`yaml\n${content}\n\`\`\``);
-      }
-    }
-  }
-
-  return sections.length > 0
-    ? `## Yuri Global Memory (L1 — pre-loaded)\n\n${sections.join('\n\n')}`
-    : '';
-}
-
-/**
- * Determine which project the message likely relates to, based on portfolio.
- */
-function resolveProjectRoot() {
-  const registryPath = path.join(YURI_GLOBAL, 'portfolio', 'registry.yaml');
-  if (!fs.existsSync(registryPath)) return null;
-
-  const registry = yaml.load(fs.readFileSync(registryPath, 'utf8')) || {};
-  const projects = registry.projects || [];
-  const active = projects.filter((p) => p.status === 'active');
-
-  if (active.length === 0) return null;
-
-  // Check global focus for active project
-  const focusPath = path.join(YURI_GLOBAL, 'focus.yaml');
-  if (fs.existsSync(focusPath)) {
-    const focus = yaml.load(fs.readFileSync(focusPath, 'utf8')) || {};
-    if (focus.active_project) {
-      const match = active.find((p) => p.id === focus.active_project);
-      if (match && fs.existsSync(match.root)) return match.root;
-    }
-  }
-
-  // Fallback: first active project
-  if (active[0] && fs.existsSync(active[0].root)) return active[0].root;
-
-  return null;
-}
-
-/**
- * Find the claude binary path.
- * Shell aliases (like `cc`) are not available in child_process, so we
- * resolve the actual binary via the user's login shell PATH.
- */
-function findClaudeBinary() {
-  // Primary: resolve via user's login shell (handles all install methods)
-  try {
-    const resolved = execSync('zsh -lc "which claude" 2>/dev/null', { encoding: 'utf8' }).trim();
-    if (resolved && fs.existsSync(resolved)) {
-      return resolved;
-    }
-  } catch {
-    // fall through
-  }
-
-  // Fallback: check common install locations
-  const candidates = [
-    '/usr/local/bin/claude',
-    '/opt/homebrew/bin/claude',
-    path.join(os.homedir(), '.npm-global', 'bin', 'claude'),
-    path.join(os.homedir(), '.local', 'bin', 'claude'),
-    path.join(os.homedir(), '.claude', 'bin', 'claude'),
-  ];
-
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
-  }
-
-  // Last resort: let the shell find it
-  return 'claude';
-}
-
-// Cache the binary path
-let _claudeBinary = null;
-function getClaudeBinary() {
-  if (!_claudeBinary) {
-    _claudeBinary = findClaudeBinary();
-    log.tmux(`Using binary: ${_claudeBinary}`);
-  }
-  return _claudeBinary;
-}
-
-// ── Session Configuration ──────────────────────────────────────────────────────
-
-const DEFAULT_SESSION = 'yuri-gateway';
-const HISTORY_LIMIT = 10000;
-
-// ── Singleton State ────────────────────────────────────────────────────────────
-
-let _sessionName = null;
-let _sessionReady = false;
-let _initPromise = null;
-let _messageQueue = Promise.resolve();
-let _messageCount = 0;       // messages since last compact/session start
-
-// ── Utilities ──────────────────────────────────────────────────────────────────
-
-function tmux(cmd) {
-  return execSync(`tmux ${cmd}`, { encoding: 'utf8', timeout: 10000 }).trim();
-}
-
-function tmuxSafe(cmd) {
-  try {
-    return tmux(cmd);
-  } catch {
-    return null;
-  }
-}
-
-// ── Claude Code TUI Indicators ─────────────────────────────────────────────────
-//
-// Claude Code TUI state indicators vary by version and statusline config:
-//
-//   Idle indicators (any of these = ready for input):
-//     ○  (U+25CB) — circle idle indicator (shown with certain statusline configs)
-//     ❯           — prompt cursor (always shown when idle, most reliable)
-//
-//   Processing indicators:
-//     ●  (U+25CF) — filled circle, active generation
-//     Braille spinner: ⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏
-//
-//   Status line elements (NOT state indicators):
-//     ◐  — effort level indicator (e.g. "◐ medium · /effort"), NOT approval prompt
-//
-//   Completion message (past-tense verb + duration):
-//     "Baked for 31s", "Worked for 2m 45s"
-//     Pattern: /[A-Z][a-z]*ed for \d+/
-//
-// ────────────────────────────────────────────────────────────────────────────────
-
-const BRAILLE_SPINNER = /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/;
-const COMPLETION_RE = /[A-Z][a-z]*ed for \d+/;
-const IDLE_RE = /[○❯]/;
-const PROCESSING_RE = /●/;
-
-/**
- * Strip TUI chrome from captured pane output.
- * `tmux capture-pane -p` (without -e) already strips most ANSI codes,
- * but we clean up residual artifacts and Claude Code UI elements.
- */
-function stripChrome(raw) {
-  return raw
-    // ANSI escape sequences
-    .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '')
-    .replace(/\x1B\].*?\x07/g, '')
-    // TUI indicators and decorations
-    .replace(/[○●◐◑⏺]/g, '')
-    .replace(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/g, '')
-    .replace(/[⏵━─█·…→]/g, '')
-    // Claude Code banner
-    .replace(/^.*▐▛.*$/gm, '')
-    .replace(/^.*▝▜.*$/gm, '')
-    .replace(/^.*▘▘.*$/gm, '')
-    .replace(/^.*Claude Code v[\d.]+.*$/gm, '')
-    .replace(/^.*Opus.*context.*$/gm, '')
-    // Status line elements
-    .replace(/^.*bypass permissions.*$/gm, '')
-    .replace(/^.*shift\+tab to cycle.*$/gm, '')
-    .replace(/^.*◐\s*(min|medium|max|low|high).*$/gm, '')
-    .replace(/^.*\/effort.*$/gm, '')
-    .replace(/^.*Proxy\s*-\s*(On|Off).*$/gm, '')
-    // Shell commands that leaked
-    .replace(/^.*export\s+CLAUDE_AUTOCOMPACT.*$/gm, '')
-    .replace(/^.*dangerously-skip-permissions.*$/gm, '')
-    // Completion stats and spinner verbs
-    .replace(/^.*[A-Z][a-z]*ed for \d+.*$/gm, '')
-    .replace(/^.*[A-Z][a-z]*ing\.{3}.*$/gm, '')
-    // Prompt cursor and line decorations
-    .replace(/^❯\s*$/gm, '')
-    .replace(/^─+$/gm, '')
-    // Line-number gutter
-    .replace(/^\s*\d+\s*[│|]\s*/gm, '')
-    // Collapse blank lines
-    .replace(/^\s*$/gm, '')
-    .replace(/\n{3,}/g, '\n\n')
-    .trim();
-}
-
-// ── Session Lifecycle ──────────────────────────────────────────────────────────
-
-function hasSession(name) {
-  return tmuxSafe(`has-session -t ${name} 2>/dev/null`) !== null;
-}
-
-function capturePaneRaw(name, lines) {
-  return tmuxSafe(`capture-pane -t ${name}:0 -p -S -${lines || 500}`) || '';
-}
-
-/**
- * Get the last N lines of the pane output for state detection.
- */
-function paneTail(name, n) {
-  return capturePaneRaw(name, n || 10);
-}
-
-/**
- * Check if Claude Code has started up and is ready for input.
- * Used ONLY during session initialization — looks for the ❯ input prompt
- * which appears once Claude Code has fully loaded.
- *
- * DO NOT use this for response completion detection — ❯ is always visible.
- */
-function isStarted(name) {
-  const tail = paneTail(name, 15);
-  return IDLE_RE.test(tail);
-}
-
-/**
- * Check if a completion message is present in the pane output.
- * e.g. "Baked for 31s", "Worked for 2m 45s"
- * This is the most reliable signal that Claude has finished responding.
- */
-function hasCompletionMessage(text) {
-  return COMPLETION_RE.test(text);
-}
-
-/**
- * Check if Claude Code is actively processing (● spinner visible).
- */
-function isProcessing(text) {
-  return PROCESSING_RE.test(text) || BRAILLE_SPINNER.test(text);
-}
-
-// ── Context Management ─────────────────────────────────────────────────────────
-//
-// Claude Code has built-in auto-compact that triggers at ~95% context capacity.
-// We improve on this with a 3-layer strategy:
-//
-//   Layer 1: CLAUDE.md persistence
-//     Channel Mode Instructions are written to the project's CLAUDE.md.
-//     CLAUDE.md survives compaction — it's re-read from disk after compact.
-//     This means our core instructions are never lost.
-//
-//   Layer 2: CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=80
-//     Set at session launch to trigger auto-compact at 80% instead of 95%.
-//     This gives a comfortable buffer before context pressure causes issues.
-//
-//   Layer 3: Proactive /compact
-//     After every N messages (configurable, default 50), we proactively
-//     send /compact to keep the context lean. This prevents gradual
-//     degradation in response quality from context bloat.
-//
-// Session rebuild is only used as a last resort when the session crashes.
-// ────────────────────────────────────────────────────────────────────────────────
-
-const CHANNEL_MODE_INSTRUCTIONS = [
-  '## Channel Mode (Yuri Gateway)',
-  '',
-  'You are responding via a messaging channel (Telegram/Feishu), not a terminal.',
-  '- Keep responses concise and mobile-friendly.',
-  '- Use markdown formatting sparingly (Telegram supports basic markdown).',
-  '- If you need to perform operations, do so and report the result.',
-  '- At the end of your response, if you observed any memory-worthy signals',
-  '  (user preferences, priority changes, tech lessons, corrections),',
-  '  write them to ~/.yuri/inbox.jsonl.',
-  '- Update ~/.yuri/focus.yaml and the project\'s focus.yaml after any operation.',
-].join('\n');
-
-/**
- * Ensure Channel Mode Instructions exist in the project's CLAUDE.md.
- * This guarantees instructions survive auto-compact (CLAUDE.md is re-read from disk).
- */
-function ensureClaudeMd(projectRoot) {
-  if (!projectRoot) return;
-
-  const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
-  const marker = '## Channel Mode (Yuri Gateway)';
-
-  let content = '';
-  if (fs.existsSync(claudeMdPath)) {
-    content = fs.readFileSync(claudeMdPath, 'utf8');
-    if (content.includes(marker)) return; // already present
-  }
-
-  // Append channel mode instructions
-  const separator = content.trim() ? '\n\n' : '';
-  fs.writeFileSync(claudeMdPath, content + separator + CHANNEL_MODE_INSTRUCTIONS + '\n');
-  log.tmux(`Channel Mode Instructions written to ${claudeMdPath}`);
-}
-
-/**
- * Send /compact to Claude Code to proactively free context space.
- * Returns true if compact completed successfully.
- */
-async function proactiveCompact(name) {
-  log.tmux('Proactive /compact triggered');
-  injectMessage(name, '/compact focus on the most recent user conversation and any pending operations');
-
-  const ok = await waitForReady(name, 120000); // compact can take up to 2min
-  if (ok) {
-    _messageCount = 0;
-    log.tmux('Proactive /compact completed');
-  } else {
-    log.warn('Proactive /compact timed out');
-  }
-  return ok;
-}
-
-/**
- * Create a new tmux session and start Claude Code inside it.
- */
-async function createSession(engineConfig) {
-  const sessionName = engineConfig.tmux_session || DEFAULT_SESSION;
-  _sessionName = sessionName;
-  _sessionReady = false;
-  _messageCount = 0;
-
-  const binary = getClaudeBinary();
-  const projectRoot = resolveProjectRoot() || os.homedir();
-  log.tmux(`Binary: ${binary}`);
-  log.tmux(`Project root: ${projectRoot}`);
-
-  // Ensure CLAUDE.md has channel mode instructions (survives compact)
-  ensureClaudeMd(projectRoot);
-
-  // Kill existing broken session (ensureSession already checked if it was healthy)
-  if (hasSession(sessionName)) {
-    log.tmux(`Replacing unhealthy session "${sessionName}"`);
-    tmuxSafe(`kill-session -t ${sessionName}`);
-  }
-
-  // Create session with generous scrollback
-  tmux(`new-session -d -s ${sessionName} -n claude -c "${projectRoot}"`);
-  tmux(`set-option -t ${sessionName} history-limit ${HISTORY_LIMIT}`);
-  log.tmux(`Session "${sessionName}" created, launching Claude Code...`);
-
-  // Set env var and launch Claude Code in a single command to keep pane clean.
-  // Using && chains avoids separate shell prompt lines polluting capture output.
-  const compactPct = engineConfig.autocompact_pct || 80;
-  tmux(`send-keys -t ${sessionName}:0 'export CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=${compactPct} && "${binary}" --dangerously-skip-permissions' Enter`);
-
-  // Wait for Claude Code to initialize (detect ❯ prompt)
-  const startupTimeout = engineConfig.startup_timeout || 60000;
-  log.tmux(`Waiting for Claude Code to start (timeout: ${startupTimeout / 1000}s)...`);
-  const started = await waitForReady(sessionName, startupTimeout);
-  if (!started) {
-    const tail = paneTail(sessionName, 10);
-    log.error(`Claude Code did not start within ${startupTimeout / 1000}s`);
-    log.error(`Last pane output:\n${tail}`);
-    log.info(`Debug: tmux attach -t ${sessionName}`);
-    throw new Error(`Claude Code did not start within ${startupTimeout / 1000}s`);
-  }
-
-  // Clear tmux scrollback so session setup commands don't pollute response capture.
-  // The pane currently contains: shell commands, banner, status line.
-  // We want captureResponse to only see content from user messages onward.
-  await new Promise((r) => setTimeout(r, 1000)); // let TUI fully render
-  tmuxSafe(`clear-history -t ${sessionName}:0`);
-
-  // NOTE: We do NOT inject L1 context here. Instead, composePrompt() prepends
-  // L1 to the first user message. This avoids: (1) scrollback pollution from
-  // a huge YAML block, (2) waitForReady returning immediately because ❯ is
-  // always visible, (3) race conditions between L1 processing and first message.
-
-  _sessionReady = true;
-  log.tmux(`Session "${sessionName}" ready (cwd: ${projectRoot})`);
-}
-
-/**
- * Wait for Claude Code to be ready (❯ prompt visible).
- * Used for session init and after /compact — NOT for response capture.
- *
- * @returns {Promise<boolean>} true if ready detected, false if timeout
- */
-function waitForReady(name, timeoutMs) {
-  const pollInterval = 2000;
-  return new Promise((resolve) => {
-    const deadline = Date.now() + timeoutMs;
-    const poll = () => {
-      if (Date.now() > deadline) {
-        return resolve(false);
-      }
-      if (!hasSession(name)) {
-        return resolve(false);
-      }
-
-      if (isStarted(name)) {
-        return resolve(true);
-      }
-      setTimeout(poll, pollInterval);
-    };
-    setTimeout(poll, pollInterval); // initial delay
-  });
-}
-
-/**
- * Inject a message into the tmux pane via load-buffer (avoids shell escaping issues).
- */
-function injectMessage(name, text) {
-  const tmpFile = path.join(os.tmpdir(), `yuri-tmux-msg-${Date.now()}.txt`);
-  fs.writeFileSync(tmpFile, text);
-
-  try {
-    tmux(`load-buffer -b yuri-input "${tmpFile}"`);
-    tmux(`paste-buffer -b yuri-input -t ${name}:0`);
-    tmux(`send-keys -t ${name}:0 Enter`);
-  } finally {
-    try { fs.unlinkSync(tmpFile); } catch {}
-  }
-}
-
-/**
- * Capture the response after injecting a message.
- *
- * Detection strategy (❯ prompt is always visible, so we CANNOT use idle detection):
- *   P1: Completion message — "[Verb]ed for [N]s/m" (e.g. "Baked for 31s")
- *       Most reliable signal. Appears exactly once when Claude finishes.
- *   P2: Content stability — pane output unchanged for N consecutive polls.
- *       Fallback for edge cases where completion message is missed.
- *
- * We also track whether content has changed since injection (via marker)
- * to avoid returning before Claude has even started responding.
- */
-async function captureResponse(name, engineConfig) {
-  const timeout = engineConfig.timeout || 300000;
-  const pollInterval = engineConfig.poll_interval || 2000;
-  const stableThreshold = engineConfig.stable_count || 3;
-
-  const deadline = Date.now() + timeout;
-  let lastHash = '';
-  let stableCount = 0;
-  let contentChanged = false;
-
-  // Capture baseline right after injection
-  const baselineRaw = capturePaneRaw(name, 500);
-  const baselineHash = crypto.createHash('md5').update(baselineRaw).digest('hex');
-  lastHash = baselineHash;
-
-  return new Promise((resolve) => {
-    const poll = () => {
-      // Timeout: return whatever we have
-      if (Date.now() > deadline) {
-        log.warn('Response capture timed out');
-        const raw = capturePaneRaw(name, 500);
-        return resolve(extractResponse(raw, baselineRaw));
-      }
-
-      // Session died
-      if (!hasSession(name)) {
-        return resolve({ reply: '❌ Claude Code session terminated unexpectedly.', raw: '' });
-      }
-
-      const raw = capturePaneRaw(name, 500);
-      const hash = crypto.createHash('md5').update(raw).digest('hex');
-
-      // Track if content has changed since injection
-      if (hash !== baselineHash) {
-        contentChanged = true;
-      }
-
-      // P1: Completion message — most reliable done signal
-      if (contentChanged && hasCompletionMessage(paneTail(name, 15))) {
-        return resolve(extractResponse(raw, baselineRaw));
-      }
-
-      // P2: Content stability — pane unchanged for N polls
-      if (hash === lastHash) {
-        stableCount++;
-      } else {
-        stableCount = 0;
-        lastHash = hash;
-      }
-
-      if (contentChanged && stableCount >= stableThreshold) {
-        log.tmux('Response detected via content stability');
-        return resolve(extractResponse(raw, baselineRaw));
-      }
-
-      setTimeout(poll, pollInterval);
-    };
-
-    // Initial delay: give Claude time to start processing
-    setTimeout(poll, Math.max(pollInterval, 3000));
-  });
-}
-
-/**
- * Extract the assistant's response by diffing current pane against baseline.
- *
- * Strategy: the baseline was captured right after message injection (before
- * Claude started responding). The current capture has Claude's response + TUI
- * chrome. We diff the two to find only the new content.
- *
- * @param {string} currentRaw - Current pane capture
- * @param {string} baselineRaw - Pane capture from right after injection
- * @returns {{reply: string, raw: string}}
- */
-function extractResponse(currentRaw, baselineRaw) {
-  const currentLines = currentRaw.split('\n');
-  const baselineLines = new Set(baselineRaw.split('\n'));
-
-  // Find lines that are new (not in baseline)
-  const newLines = currentLines.filter((line) => !baselineLines.has(line));
-  let responseText = stripChrome(newLines.join('\n'));
-
-  // Remove trailing indicators and collapse blank lines
-  responseText = responseText
-    .replace(/[○●◐◑]\s*$/g, '')
-    .replace(/\n{3,}/g, '\n\n')
-    .trim();
-
-  if (!responseText) {
-    log.warn('No new content found after diffing pane output');
-    // Fallback: strip the whole current output
-    responseText = stripChrome(currentLines.slice(-30).join('\n')).trim();
-  }
-
-  return { reply: responseText || '(no response captured)', raw: currentRaw };
-}
-
-// ── Public API ─────────────────────────────────────────────────────────────────
-
-/**
- * Ensure the tmux session is alive and ready.
- * - If session already exists with Claude Code running → reuse it
- * - If session doesn't exist → create fresh
- * - If session exists but Claude Code crashed → recreate
- */
-async function ensureSession(engineConfig) {
-  const sessionName = engineConfig.tmux_session || DEFAULT_SESSION;
-
-  // Fast path: session alive and marked ready in this process
-  if (_sessionName === sessionName && hasSession(sessionName) && _sessionReady) {
-    return;
-  }
-
-  // Check if session exists from a previous gateway run
-  if (hasSession(sessionName) && isStarted(sessionName)) {
-    log.tmux(`Reusing existing session "${sessionName}" (Claude Code is running)`);
-    _sessionName = sessionName;
-    _sessionReady = true;
-    return;
-  }
-
-  // Prevent concurrent initialization
-  if (_initPromise) {
-    return _initPromise;
-  }
-
-  const maxRetries = engineConfig.max_retries || 3;
-  _initPromise = (async () => {
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      try {
-        await createSession(engineConfig);
-        return;
-      } catch (err) {
-        log.warn(`Session init attempt ${attempt}/${maxRetries} failed: ${err.message}`);
-        if (attempt === maxRetries) {
-          log.error('All init attempts failed. Check Claude Code installation and tmux.');
-          log.info(`Debug: tmux attach -t ${sessionName}`);
-          throw err;
-        }
-        if (hasSession(sessionName)) tmuxSafe(`kill-session -t ${sessionName}`);
-        await new Promise((r) => setTimeout(r, 3000));
-      }
-    }
-  })();
-
-  try {
-    await _initPromise;
-  } finally {
-    _initPromise = null;
-  }
-}
-
-/**
- * Send a message to Claude Code via the persistent tmux session.
- *
- * @param {object} opts
- * @param {string} opts.prompt - User message to send
- * @param {string} opts.cwd - Working directory (used for session init, not per-message)
- * @param {object} opts.engineConfig - Engine configuration
- * @param {number} [opts.timeout=300000] - Timeout in ms
- * @returns {Promise<{reply: string, raw: string}>}
- */
-async function callClaude(opts) {
-  const { prompt, engineConfig, timeout } = opts;
-  const config = { ...engineConfig, timeout: timeout || engineConfig.timeout || 300000 };
-
-  // Queue messages to prevent concurrent injection into the same pane
-  return new Promise((resolve, reject) => {
-    _messageQueue = _messageQueue.then(async () => {
-      try {
-        await ensureSession(config);
-
-        // Layer 3: Proactive compact after N messages
-        const compactEvery = config.compact_every || 50;
-        if (_messageCount >= compactEvery) {
-          await proactiveCompact(_sessionName);
-        }
-
-        // Inject user message (no marker — extraction uses completion message position)
-        injectMessage(_sessionName, prompt);
-        const result = await captureResponse(_sessionName, config);
-
-        _messageCount++;
-        resolve(result);
-      } catch (err) {
-        log.error(`callClaude error: ${err.message}`);
-
-        // Mark session as not ready so it gets recreated next time
-        _sessionReady = false;
-        resolve({ reply: `❌ tmux engine error: ${err.message}`, raw: '' });
-      }
-    }).catch(reject);
-  });
-}
-
-/**
- * Compose prompt for the persistent session.
- * First message includes L1 context to prime the session.
- * Subsequent messages send only the raw user text.
- *
- * @param {string} userMessage - The user's message text
- * @param {Array} _chatHistory - Unused (Claude keeps its own context)
- * @returns {string}
- */
-function composePrompt(userMessage, _chatHistory) {
-  // First message: prepend L1 context so Claude knows who it is
-  if (_messageCount === 0) {
-    const l1 = loadL1Context();
-    if (l1) {
-      return `${l1}\n\n---\n\nUser message: ${userMessage}`;
-    }
-  }
-  return userMessage;
-}
-
-/**
- * Destroy the tmux session. Called on gateway shutdown.
- */
-function destroySession() {
-  if (_sessionName && hasSession(_sessionName)) {
-    tmuxSafe(`kill-session -t ${_sessionName}`);
-    log.tmux(`Session "${_sessionName}" destroyed.`);
-  }
-  _sessionName = null;
-  _sessionReady = false;
-  _initPromise = null;
-}
-
-module.exports = {
-  callClaude,
-  composePrompt,
-  loadL1Context,
-  resolveProjectRoot,
-  findClaudeBinary,
-  ensureSession,
-  destroySession,
-};