orchestrix-yuri 3.0.1 → 3.1.1

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

@@ -12,6 +12,30 @@ const { log } = require('../log');
 
 // ── Shared Utilities ───────────────────────────────────────────────────────────
 
+/**
+ * Check if a YAML file is still an empty template (all leaf values are "", [], null).
+ */
+function isEmptyTemplate(yamlContent) {
+  try {
+    const parsed = yaml.load(yamlContent);
+    if (!parsed || typeof parsed !== 'object') return true;
+    return checkAllEmpty(parsed);
+  } catch { return true; }
+}
+
+function checkAllEmpty(obj) {
+  for (const val of Object.values(obj)) {
+    if (val === null || val === undefined || val === '') continue;
+    if (Array.isArray(val) && val.length === 0) continue;
+    if (typeof val === 'object' && !Array.isArray(val)) {
+      if (!checkAllEmpty(val)) return false;
+      continue;
+    }
+    return false; // non-empty leaf found
+  }
+  return true;
+}
+
 function loadL1Context() {
   const files = [
     { label: 'Yuri Identity', path: path.join(YURI_GLOBAL, 'self.yaml') },
@@ -23,12 +47,11 @@ function loadL1Context() {
 
   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\`\`\``);
-      }
-    }
+    if (!fs.existsSync(f.path)) continue;
+    const content = fs.readFileSync(f.path, 'utf8').trim();
+    // Skip empty template files — they waste tokens and confuse Claude with name: ""
+    if (!content || isEmptyTemplate(content)) continue;
+    sections.push(`### ${f.label}\n\`\`\`yaml\n${content}\n\`\`\``);
   }
 
   return sections.length > 0
@@ -93,6 +116,7 @@ function getClaudeBinary() {
 let _sessionId = null;
 let _messageCount = 0;
 let _messageQueue = Promise.resolve();
+let _lastL1Hash = null;
 
 // ── System Prompt ──────────────────────────────────────────────────────────────
 
@@ -105,10 +129,9 @@ const CHANNEL_MODE_INSTRUCTIONS = [
   '- 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.',
+  '- Memory signals (preferences, identity, priorities) are detected and',
+  '  processed automatically by the gateway. You do not need to write to',
+  '  inbox.jsonl or manage memory files manually.',
 ].join('\n');
 
 /**
@@ -334,11 +357,28 @@ async function callClaude(opts) {
 }
 
 /**
- * Compose prompt — just returns the raw user message.
- * L1 context and channel instructions are handled by --system-prompt.
+ * Compose prompt for the user message.
+ * If L1 context has changed since the last call (e.g., reflect engine updated
+ * boss/preferences.yaml), prepend a context refresh block so the resumed
+ * session gets the latest memory without needing a new system prompt.
  */
-function composePrompt(userMessage, _chatHistory) {
-  return userMessage;
+function composePrompt(userMessage) {
+  const crypto = require('crypto');
+  const l1 = loadL1Context();
+  const l1Hash = crypto.createHash('md5').update(l1 || '').digest('hex');
+
+  // First call or L1 unchanged: just the user message
+  if (!_lastL1Hash || l1Hash === _lastL1Hash) {
+    _lastL1Hash = l1Hash;
+    return userMessage;
+  }
+
+  // L1 changed: prepend context refresh
+  _lastL1Hash = l1Hash;
+  if (!l1) return userMessage;
+
+  log.engine('L1 context changed, injecting refresh into prompt');
+  return `[CONTEXT UPDATE — Your global memory has been updated]\n${l1}\n[END CONTEXT UPDATE]\n\n${userMessage}`;
 }
 
 /**

package/lib/gateway/engine/reflect.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const yaml = require('js-yaml');
+const { log } = require('../log');
+
+const YURI_GLOBAL = path.join(os.homedir(), '.yuri');
+const INBOX_PATH = path.join(YURI_GLOBAL, 'inbox.jsonl');
+
+// Signal → target file mapping (mirrors observe-signals.yaml)
+const SIGNAL_TARGETS = {
+  boss_preference:  path.join(YURI_GLOBAL, 'boss', 'preferences.yaml'),
+  boss_identity:    path.join(YURI_GLOBAL, 'boss', 'profile.yaml'),
+  priority_change:  path.join(YURI_GLOBAL, 'portfolio', 'priorities.yaml'),
+  // tech_lesson and correction are project-specific, handled separately
+  // emotion stays in inbox for context
+};
+
+const MAX_INBOX_LINES = 100;
+const KEEP_INBOX_LINES = 50;
+
+/**
+ * Reflect Engine (F.1) — Process unprocessed inbox signals.
+ *
+ * Reads inbox.jsonl, groups entries by signal type, appends raw observations
+ * to target YAML files under an `observed:` array. Claude interprets these
+ * observations contextually on the next system prompt load.
+ *
+ * @returns {number} Number of entries processed
+ */
+function runReflect() {
+  if (!fs.existsSync(INBOX_PATH)) return 0;
+
+  const raw = fs.readFileSync(INBOX_PATH, 'utf8').trim();
+  if (!raw) return 0;
+
+  // Parse all entries
+  const entries = [];
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  // Filter unprocessed
+  const unprocessed = entries.filter((e) => !e.processed);
+  if (unprocessed.length === 0) return 0;
+
+  // Group by signal type
+  const groups = {};
+  for (const entry of unprocessed) {
+    const sig = entry.signal || 'unknown';
+    if (!groups[sig]) groups[sig] = [];
+    groups[sig].push(entry);
+  }
+
+  // Process each group
+  let processedCount = 0;
+
+  for (const [signal, items] of Object.entries(groups)) {
+    const targetPath = SIGNAL_TARGETS[signal];
+    if (!targetPath) {
+      // No target file for this signal type (e.g., emotion, correction)
+      // Just mark as processed
+      for (const item of items) item.processed = true;
+      processedCount += items.length;
+      continue;
+    }
+
+    try {
+      appendObservations(targetPath, signal, items);
+      for (const item of items) item.processed = true;
+      processedCount += items.length;
+    } catch (err) {
+      log.warn(`Reflect: failed to write ${signal} to ${targetPath}: ${err.message}`);
+    }
+  }
+
+  if (processedCount > 0) {
+    log.engine(`Reflect: processed ${processedCount} inbox signals`);
+  }
+
+  // Rewrite inbox with processed markers (atomic write)
+  rewriteInbox(entries);
+
+  return processedCount;
+}
+
+/**
+ * Append raw observations to a target YAML file's `observed:` array.
+ * Preserves existing content and structured fields.
+ */
+function appendObservations(targetPath, signal, items) {
+  let doc = {};
+
+  if (fs.existsSync(targetPath)) {
+    const content = fs.readFileSync(targetPath, 'utf8');
+    doc = yaml.load(content) || {};
+  }
+
+  // Initialize observed array if missing
+  if (!Array.isArray(doc.observed)) {
+    doc.observed = [];
+  }
+
+  // Append new observations
+  for (const item of items) {
+    doc.observed.push({
+      ts: item.ts,
+      signal,
+      raw: item.raw,
+      context: item.context || '',
+    });
+  }
+
+  // Keep only last 30 observations to prevent unbounded growth
+  if (doc.observed.length > 30) {
+    doc.observed = doc.observed.slice(-30);
+  }
+
+  // Write atomically: temp file then rename
+  const tmpPath = targetPath + '.tmp';
+  const header = getFileHeader(signal);
+  const yamlContent = yaml.dump(doc, { lineWidth: -1 });
+  fs.writeFileSync(tmpPath, header + yamlContent);
+  fs.renameSync(tmpPath, targetPath);
+}
+
+/**
+ * Get the header comment for a target file (preserves documentation).
+ */
+function getFileHeader(signal) {
+  switch (signal) {
+    case 'boss_preference':
+      return '# Boss Preferences — accumulated understanding of user preferences\n' +
+             '# Location: ~/.yuri/boss/preferences.yaml\n\n';
+    case 'boss_identity':
+      return '# Boss Profile — accumulated understanding of the user\n' +
+             '# Location: ~/.yuri/boss/profile.yaml\n\n';
+    case 'priority_change':
+      return '# Portfolio Priorities — project priority signals\n' +
+             '# Location: ~/.yuri/portfolio/priorities.yaml\n\n';
+    default:
+      return '';
+  }
+}
+
+/**
+ * Atomically rewrite inbox.jsonl with updated entries.
+ * Truncates if too many lines.
+ */
+function rewriteInbox(entries) {
+  // Truncate: keep only recent entries if exceeding max
+  let toWrite = entries;
+  if (toWrite.length > MAX_INBOX_LINES) {
+    toWrite = toWrite.slice(-KEEP_INBOX_LINES);
+  }
+
+  const content = toWrite.map((e) => JSON.stringify(e)).join('\n') + '\n';
+  const tmpPath = INBOX_PATH + '.tmp';
+  fs.writeFileSync(tmpPath, content);
+  fs.renameSync(tmpPath, INBOX_PATH);
+}
+
+module.exports = { runReflect };

package/lib/gateway/router.js

@@ -8,6 +8,7 @@ const yaml = require('js-yaml');
 const { ChatHistory } = require('./history');
 const { OwnerBinding } = require('./binding');
 const engine = require('./engine/claude-sdk');
+const { runReflect } = require('./engine/reflect');
 const { log } = require('./log');
 
 const YURI_GLOBAL = path.join(os.homedir(), '.yuri');
@@ -78,21 +79,19 @@ class Router {
   }
 
   async _processMessage(msg) {
+    // ═══ ENGINE: Reflect (code-enforced) ═══
+    // Process any unprocessed inbox signals BEFORE the Claude call,
+    // so the updated memory is available in the system prompt.
+    try { runReflect(); } catch (err) { log.warn(`Reflect failed: ${err.message}`); }
+
     // ═══ ENGINE: Catch-up (code-enforced) ═══
     await this._runCatchUp();
 
-    // ═══ ENGINE: Load L1 (code pre-loads into prompt) ═══
-    // L1 is loaded inside composePrompt() — injected into the prompt automatically.
-    // Claude does not need to "remember" to read these files.
-
     // ═══ Resolve project context ═══
     const projectRoot = engine.resolveProjectRoot();
 
-    // ═══ Get chat history for conversation continuity ═══
-    const chatHistory = this.history.getRecent(msg.chatId);
-
-    // ═══ Compose prompt: L1 context + chat history + user message ═══
-    const prompt = engine.composePrompt(msg.text, chatHistory);
+    // ═══ Compose prompt ═══
+    const prompt = engine.composePrompt(msg.text);
 
     // ═══ WORK: Call Claude engine ═══
     log.router(`Processing: "${msg.text.slice(0, 80)}..." → cwd: ${projectRoot || '~'}`);
@@ -106,11 +105,9 @@ class Router {
     this.history.append(msg.chatId, 'user', msg.text);
     this.history.append(msg.chatId, 'assistant', result.reply.slice(0, 2000));
 
-    // ═══ ENGINE: Observe (code writes inbox) ═══
-    // In channel mode, observations are extracted from Claude's response.
-    // Claude is instructed to write to inbox.jsonl directly via the Channel Mode Instructions.
-    // Additionally, we detect priority signals from the user's message here.
-    this._detectBasicSignals(msg);
+    // ═══ ENGINE: Observe (code-enforced signal detection) ═══
+    // Detect signals from BOTH user message and Claude's response.
+    this._detectSignals(msg, result.reply);
 
     // ═══ ENGINE: Update Focus (code-enforced) ═══
     this._updateGlobalFocus(msg, projectRoot);
@@ -170,27 +167,76 @@ class Router {
     }
   }
 
+  // ── Signal Detection Patterns (word-boundary aware) ──
+
+  static PRIORITY_PATTERNS = [
+    /\b(focus\s+on|switch\s+to|prioritize)\b/i,
+    /\b(pause|stop|halt)\s+(this|the|project|work|development)/i,
+    /\b(urgent|deadline|asap)\b/i,
+    /先搞|暂停\s*(这个|项目|开发)|不做了/,
+  ];
+
+  static PREFERENCE_PATTERNS = [
+    /\b(from\s+now\s+on|going\s+forward|always|never)\b/i,
+    /\b(don't|do\s+not|stop)\s+(use|do|write|send|make|add)/i,
+    /\b(I\s+prefer|I\s+like|I\s+want\s+you\s+to)\b/i,
+    /(别|不要)\s*\S+/,
+    /以后/,
+  ];
+
+  static IDENTITY_PATTERNS = [
+    /\b(I\s+am\s+a|I'm\s+a|my\s+role|my\s+job|I\s+work\s+(as|in|at|on))\b/i,
+    /\b(my\s+name\s+is|I'm\s+called|call\s+me)\b/i,
+    /我是|我叫|我的角色|我负责/,
+  ];
+
+  static RESPONSE_PREFERENCE_HINTS = [
+    /I'll remember|noted|preference saved|got it/i,
+    /记住了|已记录|偏好已/,
+  ];
+
+  static RESPONSE_IDENTITY_HINTS = [
+    /your role|you mentioned you|your expertise|your name/i,
+    /你的角色|你提到/,
+  ];
+
   /**
-   * Detect basic signals from the user's message (code-level observation).
+   * Detect signals from user message AND Claude's response.
+   * Uses word-boundary regex to avoid false positives.
    */
-  _detectBasicSignals(msg) {
-    const text = msg.text.toLowerCase();
+  _detectSignals(msg, claudeReply) {
     const inboxPath = path.join(YURI_GLOBAL, 'inbox.jsonl');
-
     const signals = [];
 
-    // Priority change signals
-    const priorityPatterns = ['先搞', '暂停', '不做了', 'urgent', 'deadline', 'focus on', 'pause', 'stop'];
-    if (priorityPatterns.some((p) => text.includes(p))) {
-      signals.push({ signal: 'priority_change', raw: msg.text });
+    const text = msg.text;
+
+    // Detect from user message
+    if (Router.PRIORITY_PATTERNS.some((re) => re.test(text))) {
+      signals.push({ signal: 'priority_change', raw: text });
+    }
+    if (Router.PREFERENCE_PATTERNS.some((re) => re.test(text))) {
+      signals.push({ signal: 'boss_preference', raw: text });
+    }
+    if (Router.IDENTITY_PATTERNS.some((re) => re.test(text))) {
+      signals.push({ signal: 'boss_identity', raw: text });
     }
 
-    // Preference signals
-    const prefPatterns = ['别', '不要', 'don\'t', 'stop doing', 'from now on', '以后'];
-    if (prefPatterns.some((p) => text.includes(p))) {
-      signals.push({ signal: 'boss_preference', raw: msg.text });
+    // Detect from Claude's response (confirms Claude recognized a signal)
+    if (claudeReply) {
+      if (Router.RESPONSE_PREFERENCE_HINTS.some((re) => re.test(claudeReply))) {
+        // Only add if we didn't already detect from user message
+        if (!signals.some((s) => s.signal === 'boss_preference')) {
+          signals.push({ signal: 'boss_preference', raw: text });
+        }
+      }
+      if (Router.RESPONSE_IDENTITY_HINTS.some((re) => re.test(claudeReply))) {
+        if (!signals.some((s) => s.signal === 'boss_identity')) {
+          signals.push({ signal: 'boss_identity', raw: text });
+        }
+      }
     }
 
+    // Write to inbox
     for (const sig of signals) {
       const entry = {
         ts: new Date().toISOString(),
@@ -201,6 +247,10 @@ class Router {
       };
       fs.appendFileSync(inboxPath, JSON.stringify(entry) + '\n');
     }
+
+    if (signals.length > 0) {
+      log.router(`Detected ${signals.length} signal(s): ${signals.map((s) => s.signal).join(', ')}`);
+    }
   }
 
   /**

package/lib/installer.js

@@ -130,15 +130,17 @@ function initGlobalMemory() {
     }
   }
 
-  // Empty files: only create if not already present
-  const emptyFiles = [
-    path.join(YURI_GLOBAL, 'inbox.jsonl'),
-  ];
-
-  for (const filePath of emptyFiles) {
-    if (!fs.existsSync(filePath)) {
-      fs.writeFileSync(filePath, '');
-    }
+  // Inbox file: create if not present, add bootstrap signal for first interaction
+  const inboxPath = path.join(YURI_GLOBAL, 'inbox.jsonl');
+  if (!fs.existsSync(inboxPath)) {
+    const bootstrap = JSON.stringify({
+      ts: new Date().toISOString(),
+      signal: 'boss_identity',
+      raw: '(bootstrap) User just installed Yuri. On first interaction, greet them warmly as Yuri and ask for their name and role so you can personalize the experience.',
+      context: 'installer',
+      processed: false,
+    });
+    fs.writeFileSync(inboxPath, bootstrap + '\n');
   }
 
   // Wisdom files: create with header comment if not present

package/package.json

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

package/skill/SKILL.md

@@ -22,6 +22,23 @@ delivering complete projects from natural language descriptions.
 4. **Proactive reporting** at phase boundaries and every 5 minutes during monitoring.
 5. **Default language is English.** Switch to Chinese only if user explicitly requests it.
 
+## tmux Command Rules (MANDATORY)
+
+When sending ANY content to Claude Code via tmux, you MUST follow this exact 3-step pattern:
+
+```bash
+# Step 1: Send content (pastes into Claude Code's input box)
+tmux send-keys -t "$SESSION:$WINDOW" "your content here"
+# Step 2: Wait for TUI to process the paste
+sleep 1
+# Step 3: Submit the input
+tmux send-keys -t "$SESSION:$WINDOW" Enter
+```
+
+**NEVER** combine content and Enter in one `send-keys` call (e.g., `send-keys "text" Enter`).
+Claude Code's TUI needs the 1-second pause to process pasted text before receiving Enter.
+Without it, the Enter may arrive before the TUI is ready, leaving content stuck in the input box.
+
 ## Available Commands
 
 | # | Command | Description |

package/skill/tasks/yuri-create-project.md

@@ -126,6 +126,32 @@ cp "$RESOURCE_DIR/start-orchestrix.sh"     "$PROJECT_DIR/.orchestrix-core/script
 chmod +x "$PROJECT_DIR/.orchestrix-core/scripts/start-orchestrix.sh"
 ```
 
+### Step 6.1: Register Trusted Directory
+
+Claude Code shows a "trust this directory?" dialog when entering a new project for the first time.
+This blocks automated tmux-based agent operations. Pre-register the project directory as trusted:
+
+```bash
+# Add project to Claude Code's trusted directories list
+CLAUDE_SETTINGS="$HOME/.claude/settings.local.json"
+if [ -f "$CLAUDE_SETTINGS" ]; then
+  # Use node to safely merge into JSON (avoids jq dependency)
+  node -e "
+    const fs = require('fs');
+    const s = JSON.parse(fs.readFileSync('$CLAUDE_SETTINGS', 'utf8'));
+    if (!s.trustedDirectories) s.trustedDirectories = [];
+    if (!s.trustedDirectories.includes('$PROJECT_DIR')) {
+      s.trustedDirectories.push('$PROJECT_DIR');
+      fs.writeFileSync('$CLAUDE_SETTINGS', JSON.stringify(s, null, 2));
+    }
+  "
+else
+  echo '{"trustedDirectories":["'"$PROJECT_DIR"'"]}' > "$CLAUDE_SETTINGS"
+fi
+```
+
+This ensures all tmux-based agents (planning, development) can start without manual trust confirmation.
+
 ---
 
 ## Step 7: Generate core-config.yaml

package/skill/tasks/yuri-handle-change.md

@@ -70,12 +70,18 @@ SESSION="{from focus.yaml → tmux.dev_session}"
 SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
 SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" dev "$PROJECT_DIR")
 
-# Send to Dev
-tmux send-keys -t "$SESSION:2" "/clear" Enter
+# Send to Dev (3-step pattern: content → sleep → Enter)
+tmux send-keys -t "$SESSION:2" "/clear"
+sleep 1
+tmux send-keys -t "$SESSION:2" Enter
 sleep 2
-tmux send-keys -t "$SESSION:2" "/o dev" Enter
+tmux send-keys -t "$SESSION:2" "/o dev"
+sleep 1
+tmux send-keys -t "$SESSION:2" Enter
 sleep 12
-tmux send-keys -t "$SESSION:2" "*solo \"$CHANGE_DESCRIPTION\"" Enter
+tmux send-keys -t "$SESSION:2" "*solo \"$CHANGE_DESCRIPTION\""
+sleep 1
+tmux send-keys -t "$SESSION:2" Enter
 ```
 
 Monitor Dev completion, then resume normal Phase 3 monitoring.
@@ -91,29 +97,45 @@ SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
 PLAN_SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" planning "$PROJECT_DIR")
 
 # 2. Activate PO and route change
-tmux send-keys -t "$PLAN_SESSION:0" "/o po" Enter
+tmux send-keys -t "$PLAN_SESSION:0" "/o po"
+sleep 1
+tmux send-keys -t "$PLAN_SESSION:0" Enter
 sleep 15
-tmux send-keys -t "$PLAN_SESSION:0" "*route-change \"$CHANGE_DESCRIPTION\"" Enter
+tmux send-keys -t "$PLAN_SESSION:0" "*route-change \"$CHANGE_DESCRIPTION\""
+sleep 1
+tmux send-keys -t "$PLAN_SESSION:0" Enter
 ```
 
 Wait for PO routing result. Then:
 
 - IF routes to **Architect**:
 ```bash
-tmux send-keys -t "$PLAN_SESSION:0" "/clear" Enter
+tmux send-keys -t "$PLAN_SESSION:0" "/clear"
+sleep 1
+tmux send-keys -t "$PLAN_SESSION:0" Enter
 sleep 2
-tmux send-keys -t "$PLAN_SESSION:0" "/o architect" Enter
+tmux send-keys -t "$PLAN_SESSION:0" "/o architect"
+sleep 1
+tmux send-keys -t "$PLAN_SESSION:0" Enter
 sleep 15
-tmux send-keys -t "$PLAN_SESSION:0" "*resolve-change" Enter
+tmux send-keys -t "$PLAN_SESSION:0" "*resolve-change"
+sleep 1
+tmux send-keys -t "$PLAN_SESSION:0" Enter
 ```
 
 - IF routes to **PM**:
 ```bash
-tmux send-keys -t "$PLAN_SESSION:0" "/clear" Enter
+tmux send-keys -t "$PLAN_SESSION:0" "/clear"
+sleep 1
+tmux send-keys -t "$PLAN_SESSION:0" Enter
 sleep 2
-tmux send-keys -t "$PLAN_SESSION:0" "/o pm" Enter
+tmux send-keys -t "$PLAN_SESSION:0" "/o pm"
+sleep 1
+tmux send-keys -t "$PLAN_SESSION:0" Enter
 sleep 15
-tmux send-keys -t "$PLAN_SESSION:0" "*revise-prd" Enter
+tmux send-keys -t "$PLAN_SESSION:0" "*revise-prd"
+sleep 1
+tmux send-keys -t "$PLAN_SESSION:0" Enter
 ```
 
 Wait for Proposal output (PCP/TCP).
@@ -123,11 +145,17 @@ Then switch to dev session:
 DEV_SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" dev "$PROJECT_DIR")
 
 # In SM window: apply proposal
-tmux send-keys -t "$DEV_SESSION:1" "/clear" Enter
+tmux send-keys -t "$DEV_SESSION:1" "/clear"
+sleep 1
+tmux send-keys -t "$DEV_SESSION:1" Enter
 sleep 2
-tmux send-keys -t "$DEV_SESSION:1" "/o sm" Enter
+tmux send-keys -t "$DEV_SESSION:1" "/o sm"
+sleep 1
+tmux send-keys -t "$DEV_SESSION:1" Enter
 sleep 12
-tmux send-keys -t "$DEV_SESSION:1" "*apply-proposal {proposal_id}" Enter
+tmux send-keys -t "$DEV_SESSION:1" "*apply-proposal {proposal_id}"
+sleep 1
+tmux send-keys -t "$DEV_SESSION:1" Enter
 ```
 
 SM → Architect → Dev → QA auto-loop resumes.
@@ -160,9 +188,13 @@ SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
 
 # Step 1: PM generates next-steps.md
 PLAN_SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" planning "$PROJECT_DIR")
-tmux send-keys -t "$PLAN_SESSION:0" "/o pm" Enter
+tmux send-keys -t "$PLAN_SESSION:0" "/o pm"
+sleep 1
+tmux send-keys -t "$PLAN_SESSION:0" Enter
 sleep 15
-tmux send-keys -t "$PLAN_SESSION:0" "*start-iteration" Enter
+tmux send-keys -t "$PLAN_SESSION:0" "*start-iteration"
+sleep 1
+tmux send-keys -t "$PLAN_SESSION:0" Enter
 ```
 
 Monitor PM completion. PM creates: `docs/prd/epic-*.yaml` + `docs/prd/*next-steps.md`
@@ -198,11 +230,17 @@ DEV_SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" dev "$PROJECT_DIR")
 ```
 3. In SM window (window 1) of dev session:
 ```bash
-tmux send-keys -t "$DEV_SESSION:1" "/clear" Enter
+tmux send-keys -t "$DEV_SESSION:1" "/clear"
+sleep 1
+tmux send-keys -t "$DEV_SESSION:1" Enter
 sleep 2
-tmux send-keys -t "$DEV_SESSION:1" "/o sm" Enter
+tmux send-keys -t "$DEV_SESSION:1" "/o sm"
+sleep 1
+tmux send-keys -t "$DEV_SESSION:1" Enter
 sleep 12
-tmux send-keys -t "$DEV_SESSION:1" "*draft" Enter
+tmux send-keys -t "$DEV_SESSION:1" "*draft"
+sleep 1
+tmux send-keys -t "$DEV_SESSION:1" Enter
 ```
 SM creates first story → handoff chain auto-starts (SM → Arch → Dev → QA)
 

package/skill/tasks/yuri-plan-project.md

@@ -91,21 +91,37 @@ sleep 2  # Wait for Claude Code to start
 
 **2.3** Activate agent and send command:
 ```bash
-tmux send-keys -t "$SESSION:$WINDOW_IDX" "/o {agent}" Enter
+# CRITICAL: Every tmux send-keys MUST follow the pattern:
+#   send-keys "content" → sleep 1 → send-keys Enter
+# Claude Code TUI needs time to process pasted text before Enter.
+# Sending content and Enter in one call can cause the Enter to be lost.
+
+tmux send-keys -t "$SESSION:$WINDOW_IDX" "/o {agent}"
+sleep 1
+tmux send-keys -t "$SESSION:$WINDOW_IDX" Enter
 sleep 10  # Wait for agent to load
-tmux send-keys -t "$SESSION:$WINDOW_IDX" "{command}" Enter
+
+tmux send-keys -t "$SESSION:$WINDOW_IDX" "{command}"
+sleep 1
+tmux send-keys -t "$SESSION:$WINDOW_IDX" Enter
 ```
 
-**2.3.1** When answering agent questions (multi-line text):
+**2.3.1** When answering agent questions or sending any text to agent windows:
 ```bash
-# Multi-line content is treated as a "paste" by Claude Code TUI.
-# It lands in the input buffer but does NOT auto-submit.
-# You MUST send Enter immediately after the content.
+# ALWAYS use this 3-step pattern for sending content to Claude Code:
+#   Step 1: send-keys "content"    (pastes text into input box)
+#   Step 2: sleep 1                (let TUI process the paste)
+#   Step 3: send-keys Enter        (submit the input)
+#
+# NEVER combine content and Enter in a single send-keys call.
+# NEVER skip the sleep — without it, Enter may arrive before TUI is ready.
+
 tmux send-keys -t "$SESSION:$WINDOW_IDX" "$(cat <<'EOF'
 your multi-line answer here
 EOF
-)" Enter
-# ^ Enter is CRITICAL — without it, content stays in input box
+)"
+sleep 1
+tmux send-keys -t "$SESSION:$WINDOW_IDX" Enter
 ```
 
 **IMPORTANT:** Do NOT use `/clear` within the planning phase. Each agent has its own

package/skill/tasks/yuri-test-project.md

@@ -54,9 +54,13 @@ SESSION=$(bash "$SCRIPT_DIR/ensure-session.sh" dev "$PROJECT_DIR")
 
 Reload QA agent in clean state:
 ```bash
-tmux send-keys -t "$SESSION:3" "/clear" Enter
+tmux send-keys -t "$SESSION:3" "/clear"
+sleep 1
+tmux send-keys -t "$SESSION:3" Enter
 sleep 2
-tmux send-keys -t "$SESSION:3" "/o qa" Enter
+tmux send-keys -t "$SESSION:3" "/o qa"
+sleep 1
+tmux send-keys -t "$SESSION:3" Enter
 sleep 12
 ```
 
@@ -71,7 +75,9 @@ FOR EACH `EPIC_ID` in the epic list:
 ### 2.1 Run Smoke Test
 
 ```bash
-tmux send-keys -t "$SESSION:3" "*smoke-test $EPIC_ID" Enter
+tmux send-keys -t "$SESSION:3" "*smoke-test $EPIC_ID"
+sleep 1
+tmux send-keys -t "$SESSION:3" Enter
 ```
 
 Monitor completion:
@@ -95,15 +101,21 @@ IF test failed, extract bug descriptions from QA output. Then:
 
 1. Reload Dev agent:
 ```bash
-tmux send-keys -t "$SESSION:2" "/clear" Enter
+tmux send-keys -t "$SESSION:2" "/clear"
+sleep 1
+tmux send-keys -t "$SESSION:2" Enter
 sleep 2
-tmux send-keys -t "$SESSION:2" "/o dev" Enter
+tmux send-keys -t "$SESSION:2" "/o dev"
+sleep 1
+tmux send-keys -t "$SESSION:2" Enter
 sleep 12
 ```
 
 2. Send quick-fix command:
 ```bash
-tmux send-keys -t "$SESSION:2" "*quick-fix \"$BUG_DESC\"" Enter
+tmux send-keys -t "$SESSION:2" "*quick-fix \"$BUG_DESC\""
+sleep 1
+tmux send-keys -t "$SESSION:2" Enter
 ```
 
 3. Monitor Dev completion.