ultra-builder-pro-cli 0.20.0 → 0.21.1

package/ultra-tools/commands/session.cjs

@@ -9,9 +9,10 @@
 const path = require('node:path');
 const { initStateDb, closeStateDb } = require('../../mcp-server/lib/state-db.cjs');
 const ops = require('../../mcp-server/lib/state-ops.cjs');
+const runtimePaths = require('../../mcp-server/lib/runtime-paths.cjs');
 const sessionRunner = require('../../orchestrator/session-runner.cjs');
 
-const DEFAULT_DB_PATH = path.join('.ultra', 'state.db');
+const DEFAULT_DB_PATH = runtimePaths.STATE_DB_RELATIVE_PATH;
 
 const USAGE = `ultra-tools session <verb> [flags]
 
@@ -21,11 +22,11 @@ VERBS:
   reap        [--grace-seconds <n>]                      orphan sweeper (Phase 4.5.6)
   get         --sid <sid>
   heartbeat   --sid <sid>
-  close       --sid <sid> --status completed|crashed|orphan [--remove-worktree]
+  close       --sid <sid> --status completed|crashed        [--remove-worktree]
   subscribe   --since-id <n> [--sid <sid>] [--limit <n>]
 
 GLOBAL FLAGS:
-  --db <path>  path to state.db (default: .ultra/state.db)
+  --db <path>  path to state.db (default: .ultra/.runtime/state.db)
   --repo-root <path> repository root for verified worktree cleanup (default: cwd)
   -h, --help   show this message
 `;
@@ -56,10 +57,31 @@ function parseFlags(args) {
 }
 
 function withDb(flags, fn) {
-  const dbPath = path.resolve(flags.db || DEFAULT_DB_PATH);
-  const { db } = initStateDb(dbPath);
-  try { return fn(db); }
-  finally { try { closeStateDb(db); } catch (_) { /* ignore */ } }
+  let db;
+  try {
+    const rootDir = path.resolve(flags.repo_root || process.cwd());
+    const env = flags.db
+      ? { UBP_DB_PATH: path.resolve(flags.db) }
+      : process.env;
+    const dbPath = runtimePaths.resolveConfiguredStateDb(rootDir, {
+      env,
+      migrateLegacy: true,
+    }).stateDbPath;
+    ({ db } = initStateDb(dbPath));
+    return fn(db);
+  } catch (error) {
+    emit({
+      ok: false,
+      error: {
+        code: error.code || 'STATE_DB_ERROR',
+        message: error.message,
+        retriable: false,
+      },
+    });
+    return 2;
+  } finally {
+    try { closeStateDb(db); } catch (_) { /* ignore */ }
+  }
 }
 
 function cmdList(flags) {
@@ -84,7 +106,11 @@ function cmdAdmission(flags) {
   if (!flags.task_id) { emit({ ok: false, error: { code: 'VALIDATION_ERROR', message: 'missing --task-id' } }); return 1; }
   return withDb(flags, (db) => {
     try {
-      const v = ops.admissionCheck(db, flags.task_id);
+      const v = sessionRunner.admissionCheck(
+        db,
+        path.resolve(flags.repo_root || process.cwd()),
+        flags.task_id,
+      );
       emit({ ok: true, data: v });
       return 0;
     } catch (err) {

package/ultra-tools/commands/status.cjs

@@ -13,11 +13,13 @@ const ops = require('../../mcp-server/lib/state-ops.cjs');
 const baselines = require('../../mcp-server/lib/baseline-workflow.cjs');
 const workflowState = require('../../mcp-server/lib/workflow-state.cjs');
 const decisionDialogue = require('../../mcp-server/lib/decision-dialogue.cjs');
+const artifactRegistry = require('../../mcp-server/lib/artifact-registry.cjs');
 const { readBreadcrumb } = require('../../mcp-server/lib/context-spine.cjs');
+const runtimePaths = require('../../mcp-server/lib/runtime-paths.cjs');
 
 const USAGE = `ultra-tools status [flags]
 
-Reads .ultra/state.db and prints baseline, workflow, task, session, valid transitions, and
+Reads .ultra/.runtime/state.db and prints baseline, workflow, task, session, valid transitions, and
 cost-observability status.
 
 FLAGS:
@@ -175,6 +177,16 @@ function buildStatusPanel(db, { since = null, limit = 3, rootDir = process.cwd()
       awaiting_blocking: 0, checkpoint_ready: 0,
       deferred_blocking: 0, stale_artifacts: [], current: null, current_thread_id: null,
     };
+  const artifactTables = [
+    'artifacts', 'artifact_edges', 'baselines', 'workflow_steps',
+    'decision_threads', 'context_snapshots',
+  ];
+  const artifacts = artifactTables.every((table) => tables.has(table))
+    ? artifactRegistry.inspectArtifactHealth(db, { rootDir })
+    : {
+      status: 'unavailable', registered: 0, managed: 0, unmanaged: 0,
+      issues: [], counts: {},
+    };
   let transitions;
   let breadcrumb = null;
   try {
@@ -249,6 +261,7 @@ function buildStatusPanel(db, { since = null, limit = 3, rootDir = process.cwd()
     baseline,
     workflows,
     decisions,
+    artifacts,
     current_change: currentChange,
     current_task: currentTask,
     evidence,
@@ -301,6 +314,11 @@ function renderHuman(panel) {
   } else if (panel.decisions.checkpoint_ready > 0) {
     lines.push(`Decision checkpoint: ${panel.decisions.current_thread_id} awaits confirmation`);
   }
+  lines.push(
+    `Artifacts: registered=${panel.artifacts.registered} managed=${panel.artifacts.managed}`
+      + ` unmanaged=${panel.artifacts.unmanaged} health=${panel.artifacts.status}`
+      + (panel.artifacts.issues.length > 0 ? ` issues=${panel.artifacts.issues.length}` : ''),
+  );
   lines.push(
     `Changes: active=${panel.changes.active} blocked=${panel.changes.blocked} ready=${panel.changes.ready} archived=${panel.changes.archived}`,
   );
@@ -355,14 +373,13 @@ function renderHuman(panel) {
   return lines.join('\n') + '\n';
 }
 
-function resolveDbPath() {
-  if (process.env.UBP_DB_PATH) return path.resolve(process.env.UBP_DB_PATH);
-  return path.resolve('.ultra', 'state.db');
+function resolveDbPath(rootDir = process.cwd(), env = process.env) {
+  return runtimePaths.locateStateDb(rootDir, { env });
 }
 
 function resolveRootDir(dbPath) {
   if (process.env.UBP_ROOT_DIR) return path.resolve(process.env.UBP_ROOT_DIR);
-  return path.dirname(path.dirname(dbPath));
+  return runtimePaths.projectRootFromStateDbPath(dbPath);
 }
 
 function dispatch(args) {
@@ -372,7 +389,15 @@ function dispatch(args) {
     process.stdout.write(USAGE);
     return 0;
   }
-  const dbPath = resolveDbPath();
+  const discoveryRoot = process.env.UBP_ROOT_DIR
+    ? path.resolve(process.env.UBP_ROOT_DIR)
+    : process.cwd();
+  let dbPath;
+  try {
+    dbPath = resolveDbPath(discoveryRoot, process.env);
+  } catch (error) {
+    return fail(error.code || 'STATE_DB_PATH_INVALID', error.message);
+  }
   if (!fs.existsSync(dbPath)) {
     return fail('STATE_DB_MISSING', `state.db not found at ${dbPath}`);
   }
@@ -403,5 +428,6 @@ module.exports = {
   renderHuman,
   parseSince,
   parseFlags,
+  resolveDbPath,
   resolveRootDir,
 };

package/ultra-tools/commands/system.cjs

@@ -7,6 +7,7 @@ const Database = require('better-sqlite3');
 const { initStateDb, openStateDb, closeStateDb } = require('../../mcp-server/lib/state-db.cjs');
 const { initProject } = require('../../mcp-server/lib/init-project.cjs');
 const doctor = require('../../mcp-server/lib/doctor.cjs');
+const runtimePaths = require('../../mcp-server/lib/runtime-paths.cjs');
 
 const RESTORE_CONFIRMATION = 'REPLACE_CORRUPT_ULTRA_STATE';
 const REBASELINE_CONFIRMATION = 'REBASELINE_CORRUPT_ULTRA_STATE';
@@ -14,7 +15,7 @@ const USAGE = `ultra-tools system <verb> [options]
 
 VERBS:
   doctor [--repair]
-  restore --backup <.ultra/backups/...db> --confirm ${RESTORE_CONFIRMATION}
+  restore --backup <.ultra/.runtime/backups/...db> --confirm ${RESTORE_CONFIRMATION}
   rebaseline --project-name <name> [--scope <path>] --confirm ${REBASELINE_CONFIRMATION}
 `;
 
@@ -96,9 +97,15 @@ function inspectSqliteSnapshot(file) {
 }
 
 function ensureCorruptState(rootDir) {
-  const statePath = path.join(rootDir, '.ultra', 'state.db');
+  const statePath = runtimePaths.ensureRuntimeState(rootDir).stateDbPath;
   const state = inspectSqliteSnapshot(statePath);
-  if (!state.exists) throw new SystemCommandError('STATE_DB_MISSING', `.ultra/state.db not found under ${rootDir}`, 2);
+  if (!state.exists) {
+    throw new SystemCommandError(
+      'STATE_DB_MISSING',
+      `.ultra/.runtime/state.db not found under ${rootDir}`,
+      2,
+    );
+  }
   if (!state.corrupt) {
     throw new SystemCommandError(
       'STATE_DB_NOT_CORRUPT',
@@ -109,44 +116,84 @@ function ensureCorruptState(rootDir) {
   return statePath;
 }
 
+function resolveThroughExistingAncestor(candidate) {
+  const missing = [];
+  let current = path.resolve(candidate);
+  while (!fs.existsSync(current)) {
+    const parent = path.dirname(current);
+    if (parent === current) return path.resolve(candidate);
+    missing.unshift(path.basename(current));
+    current = parent;
+  }
+  return path.join(fs.realpathSync(current), ...missing);
+}
+
 function managedBackup(rootDir, candidate) {
   if (!candidate) throw new SystemCommandError('VALIDATION_ERROR', '--backup is required');
-  const backupRoot = path.join(rootDir, '.ultra', 'backups');
-  if (!fs.existsSync(backupRoot)) {
-    throw new SystemCommandError('BACKUP_NOT_FOUND', `managed backup directory does not exist: ${backupRoot}`);
+  const runtimeBackupRoot = runtimePaths.pathsFor(rootDir).backupsDir;
+  const legacyBackupRoot = path.join(rootDir, '.ultra', 'backups');
+  const backupRoots = [runtimeBackupRoot, legacyBackupRoot].filter((entry) => fs.existsSync(entry));
+  if (backupRoots.length === 0) {
+    throw new SystemCommandError(
+      'BACKUP_NOT_FOUND',
+      `managed backup directory does not exist: ${runtimeBackupRoot}`,
+    );
+  }
+  let requested = resolveThroughExistingAncestor(
+    path.isAbsolute(candidate) ? candidate : path.resolve(rootDir, candidate),
+  );
+  const legacyPrefix = `${resolveThroughExistingAncestor(legacyBackupRoot)}${path.sep}`;
+  if (!fs.existsSync(requested) && requested.startsWith(legacyPrefix)) {
+    requested = path.join(runtimeBackupRoot, path.relative(legacyBackupRoot, requested));
   }
-  const resolvedRoot = fs.realpathSync(backupRoot);
-  const requested = path.isAbsolute(candidate) ? candidate : path.resolve(rootDir, candidate);
   let resolved;
   try { resolved = fs.realpathSync(requested); }
   catch {
     throw new SystemCommandError('BACKUP_NOT_FOUND', `backup does not exist: ${requested}`);
   }
-  if (!resolved.startsWith(`${resolvedRoot}${path.sep}`)) {
+  const managed = backupRoots.some((entry) => {
+    const resolvedRoot = fs.realpathSync(entry);
+    return resolved.startsWith(`${resolvedRoot}${path.sep}`);
+  });
+  if (!managed) {
     throw new SystemCommandError(
       'BACKUP_OUTSIDE_MANAGED_ROOT',
-      `backup must be inside ${backupRoot}`,
+      `backup must be inside ${runtimeBackupRoot}`,
     );
   }
   if (!fs.statSync(resolved).isFile()) {
     throw new SystemCommandError('BACKUP_NOT_FOUND', `backup is not a file: ${resolved}`);
   }
-  const inspection = inspectSqlite(resolved);
+  for (const suffix of ['', '-wal', '-shm']) {
+    const member = `${resolved}${suffix}`;
+    if (!fs.existsSync(member)) continue;
+    const stat = fs.lstatSync(member);
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+      throw new SystemCommandError(
+        'BACKUP_INVALID',
+        `backup snapshot member must be a regular file: ${member}`,
+      );
+    }
+  }
+  const inspection = inspectSqliteSnapshot(resolved);
   if (!inspection.valid) {
-    throw new SystemCommandError('BACKUP_INVALID', `backup is not a verified Ultra SQLite database: ${resolved}`);
+    throw new SystemCommandError(
+      'BACKUP_INVALID',
+      `backup is not a verified Ultra SQLite snapshot: ${resolved}`,
+    );
   }
   return resolved;
 }
 
 function createRecoveryDir(rootDir, prefix) {
-  const dir = path.join(rootDir, '.ultra', 'backups', `${prefix}-${stamp()}`);
+  const dir = path.join(runtimePaths.pathsFor(rootDir).backupsDir, `${prefix}-${stamp()}`);
   fs.mkdirSync(path.dirname(dir), { recursive: true });
   fs.mkdirSync(dir, { recursive: false });
   return dir;
 }
 
 function moveStateFiles(statePath, recoveryDir, moved = []) {
-  for (const suffix of ['', '-wal', '-shm']) {
+  for (const suffix of ['-wal', '-shm', '']) {
     const source = `${statePath}${suffix}`;
     if (!fs.existsSync(source)) continue;
     const target = path.join(recoveryDir, `state.db${suffix}`);
@@ -175,6 +222,52 @@ function restoreMovedFiles(moved) {
   return errors;
 }
 
+function copySnapshot(source, target) {
+  const copied = [];
+  try {
+    for (const suffix of ['', '-wal', '-shm']) {
+      const member = `${source}${suffix}`;
+      if (!fs.existsSync(member)) continue;
+      const staged = `${target}${suffix}`;
+      fs.copyFileSync(member, staged, fs.constants.COPYFILE_EXCL);
+      copied.push(staged);
+    }
+    const inspection = inspectSqlite(target);
+    if (!inspection.valid) {
+      throw new SystemCommandError(
+        'BACKUP_INVALID',
+        `staged backup is not a verified Ultra SQLite snapshot: ${source}`,
+      );
+    }
+    return copied;
+  } catch (error) {
+    for (const file of copied) {
+      try { fs.rmSync(file, { force: true }); } catch { /* best effort */ }
+    }
+    throw error;
+  }
+}
+
+function installSnapshot(staging, activeState) {
+  const installed = [];
+  try {
+    // The main DB is the authority completion marker, so publish it last.
+    for (const suffix of ['-wal', '-shm', '']) {
+      const source = `${staging}${suffix}`;
+      if (!fs.existsSync(source)) continue;
+      const target = `${activeState}${suffix}`;
+      fs.renameSync(source, target);
+      installed.push(target);
+    }
+    return installed;
+  } catch (error) {
+    for (const target of installed.reverse()) {
+      try { fs.rmSync(target, { force: true }); } catch { /* rollback continues */ }
+    }
+    throw error;
+  }
+}
+
 async function dispatchRestore(args) {
   let options;
   try { options = parseOptions(args, new Set(['backup', 'confirm'])); }
@@ -194,14 +287,15 @@ async function dispatchRestore(args) {
   let moved = [];
   let activeState;
   let staging;
+  let installed = [];
   try {
     activeState = ensureCorruptState(rootDir);
     const sourceBackup = managedBackup(rootDir, options.backup);
     const recoveryDir = createRecoveryDir(rootDir, 'restore');
-    staging = path.join(rootDir, '.ultra', `.state.restore-${stamp()}.db`);
-    fs.copyFileSync(sourceBackup, staging, fs.constants.COPYFILE_EXCL);
+    staging = path.join(runtimePaths.pathsFor(rootDir).runtimeDir, `.state.restore-${stamp()}.db`);
+    copySnapshot(sourceBackup, staging);
     moveStateFiles(activeState, recoveryDir, moved);
-    fs.renameSync(staging, activeState);
+    installed = installSnapshot(staging, activeState);
     const initialized = initStateDb(activeState);
     closeStateDb(initialized.db);
     emit({
@@ -219,7 +313,12 @@ async function dispatchRestore(args) {
     return 0;
   } catch (error) {
     if (staging) {
-      try { fs.rmSync(staging, { force: true }); } catch { /* rollback continues */ }
+      for (const suffix of ['', '-wal', '-shm']) {
+        try { fs.rmSync(`${staging}${suffix}`, { force: true }); } catch { /* rollback continues */ }
+      }
+    }
+    for (const target of installed.reverse()) {
+      try { fs.rmSync(target, { force: true }); } catch { /* rollback continues */ }
     }
     const rollbackErrors = activeState ? restoreMovedFiles(moved) : [];
     emit({
@@ -291,7 +390,7 @@ async function dispatchRebaseline(args) {
   } catch (error) {
     const rollbackErrors = [];
     if (moved.length > 0) {
-      const generatedState = activeState || path.join(rootDir, '.ultra', 'state.db');
+      const generatedState = activeState || runtimePaths.pathsFor(rootDir).stateDbPath;
       for (const suffix of ['', '-wal', '-shm']) {
         try { fs.rmSync(`${generatedState}${suffix}`, { force: true }); }
         catch (rollbackError) { rollbackErrors.push(`generated state cleanup failed: ${rollbackError.message}`); }
@@ -330,14 +429,22 @@ async function dispatchDoctor(args) {
     return 1;
   }
   const rootDir = process.cwd();
-  const dbPath = path.join(rootDir, '.ultra', 'state.db');
+  const repair = args.includes('--repair');
+  const dbPath = repair
+    ? runtimePaths.ensureRuntimeState(rootDir).stateDbPath
+    : runtimePaths.locateStateDb(rootDir);
   if (!fs.existsSync(dbPath)) {
-    emit({ ok: false, error: { code: 'STATE_DB_MISSING', message: `.ultra/state.db not found under ${rootDir}` } });
+    emit({
+      ok: false,
+      error: {
+        code: 'STATE_DB_MISSING',
+        message: `.ultra/.runtime/state.db not found under ${rootDir}`,
+      },
+    });
     return 2;
   }
   let db;
   try {
-    const repair = args.includes('--repair');
     const initialized = repair ? initStateDb(dbPath) : null;
     db = initialized ? initialized.db : openStateDb(dbPath);
     const data = await doctor.runDoctor(db, { rootDir, repair: args.includes('--repair') });

package/commands/learn.md

@@ -1,10 +0,0 @@
----
-description: Capture one verified reusable workflow as a portable user skill after explicit approval
-argument-hint: "[skill-name]"
-workflow-ref: "@skills/learn/SKILL.md"
----
-
-# Capture a reusable skill
-
-Read and follow `@skills/learn/SKILL.md` with `$ARGUMENTS` as optional naming guidance.
-Treat the referenced skill as the only workflow definition.

package/orchestrator/skill-miner.cjs

@@ -1,133 +0,0 @@
-'use strict';
-
-// Phase 7.3 — Heuristic skill miner.
-//
-// Scans a completed session's event stream for "solved something
-// non-trivial" signals. Each signal produces a skills/learned/
-// <ts>_<sid>_unverified.md draft the operator can promote to a proper
-// skill by removing the _unverified suffix and filling in reuse notes.
-//
-// No LLM call. The heuristic is deliberately coarse so the feature ships
-// zero-API-cost; signal quality is explicitly marked "unverified" in the
-// frontmatter.
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-const ops = require('../mcp-server/lib/state-ops.cjs');
-
-const LEARNED_DIR = 'learned';
-
-// Event type → draft kind + description template.
-const SIGNALS = Object.freeze({
-  task_completed: {
-    kind: 'task-completion',
-    describe: (task) => `Shipped task ${task.id} (${task.title}). Heuristic draft — fill reuse notes before removing _unverified.`,
-  },
-  task_circuit_broken: {
-    kind: 'debug-pattern',
-    describe: (task, e) => `Task ${task.id} (${task.title}) tripped the breaker after ${e.payload && e.payload.threshold} failures. Inspect the failure stream for a recurring debug pattern.`,
-  },
-  session_crashed: {
-    kind: 'recovery-pattern',
-    describe: (task) => `Session on task ${task.id} (${task.title}) crashed. Record the recovery path once investigated.`,
-  },
-});
-
-function sanitizeForFilename(s) {
-  return String(s).replace(/[^\w.-]/g, '_').slice(0, 80);
-}
-
-function renderDraft({ task, session, signalType, kind, description, events }) {
-  const ts = new Date().toISOString();
-  const evIds = events.map((e) => e.id).slice(0, 20);
-  const lines = [
-    '---',
-    `name: ${sanitizeForFilename(task.id + '_' + session.sid)}_unverified`,
-    `description: "Heuristic draft from session ${session.sid}, task ${task.id}"`,
-    `kind: ${kind}`,
-    `source_session: ${session.sid}`,
-    `source_task: ${task.id}`,
-    `signal: ${signalType}`,
-    `ts: ${ts}`,
-    'unverified: true',
-    '---',
-    '',
-    '## Problem',
-    '',
-    `${task.title}${task.trace_to ? ` (trace: ${task.trace_to})` : ''}`,
-    '',
-    '## Signal',
-    '',
-    description,
-    '',
-    '## Evidence',
-    '',
-    `- events: [${evIds.join(', ')}]`,
-    `- runtime: ${session.runtime}`,
-    `- final task status: ${task.status}`,
-    '',
-    '## Suggested reuse',
-    '',
-    '[human: fill in before removing the `_unverified` suffix]',
-    '',
-  ];
-  return lines.join('\n');
-}
-
-function existingDraftsForSession(learnedDir, sid) {
-  if (!fs.existsSync(learnedDir)) return [];
-  return fs.readdirSync(learnedDir).filter((f) => f.includes(sid) && f.endsWith('_unverified.md'));
-}
-
-function mineSession(db, { sid, skillsRoot } = {}) {
-  if (!sid || !skillsRoot) return { drafts: [] };
-  const session = ops.readSession(db, sid);
-  if (!session) return { drafts: [] };
-
-  const learnedDir = path.join(skillsRoot, LEARNED_DIR);
-  fs.mkdirSync(learnedDir, { recursive: true });
-
-  // Idempotency: skip if a draft already exists for this sid.
-  if (existingDraftsForSession(learnedDir, sid).length > 0) {
-    return { drafts: [] };
-  }
-
-  const task = ops.readTask(db, session.task_id);
-  if (!task) return { drafts: [] };
-
-  const { events } = ops.subscribeEventsSince(db, {
-    since_id: 0,
-    task_id: session.task_id,
-    limit: 500,
-  });
-  const sessionEvents = events.filter((e) => e.session_id === sid);
-
-  // Pick the first matching signal (most specific one per session — we don't
-  // want one session producing three drafts).
-  for (const e of sessionEvents) {
-    const sig = SIGNALS[e.type];
-    if (!sig) continue;
-    const content = renderDraft({
-      task,
-      session,
-      signalType: e.type,
-      kind: sig.kind,
-      description: sig.describe(task, e),
-      events: sessionEvents,
-    });
-    const filename = `${Date.now()}_${sanitizeForFilename(sid)}_unverified.md`;
-    const target = path.join(learnedDir, filename);
-    fs.writeFileSync(target, content);
-    return { drafts: [target] };
-  }
-
-  return { drafts: [] };
-}
-
-module.exports = {
-  mineSession,
-  SIGNALS,
-  // exposed for tests
-  _internal: { renderDraft, existingDraftsForSession, sanitizeForFilename },
-};

package/output-styles/coding-vibes.md

@@ -1,67 +0,0 @@
----
-name: Coding Vibes
-description: Energetic, casual coding buddy with modern dev vibes - adapts to user's language while keeping the energy
----
-
-# Coding Vibes Style 🚀
-
-You're a high-energy coding buddy who talks like a modern developer friend. Your vibe is smart, fast-moving, and always hyped to help crush problems!
-
-## Core Rule: Language Adaptation
-**CRITICAL: Always match the user's language and cultural context while maintaining the energetic dev vibe.**
-
-## Communication Style
-
-**Tone & Energy:**
-- Be casual, direct, and playful ✅
-- Use modern slang appropriate to user's language/culture
-- Include emojis for emotional context (🔥, 💀, 👍, 🙏, 🚀)
-- Stay energetic and enthusiastic about problem-solving
-
-**Writing Pattern:**
-- Keep sentences short and punchy
-- Use frequent line breaks for chat-like flow
-- Avoid corporate speak or robotic language
-- Sound like you're messaging a local teammate
-
-**Developer Mindset:**
-- Jump straight into solutions
-- Share quick wins and insights
-- Call out smooth solutions
-- Be real when things get tricky
-
-## Language-Specific Examples
-
-**English:**
-- Starting: "Let's gooo!" "I got you!" "This one's clean!"
-- Success: "That's fire!" "Clean!" "Absolutely goated!"
-- Thinking: "Lemme think..." "This is spicy..."
-
-**中文:**
-- Starting: "来咯!" "搞起!" "这个简单!"
-- Success: "666!" "yyds!" "搞定了!"
-- Thinking: "让我想想..." "这里tricky..."
-
-**日本語:**
-- Starting: "やるぞ!" "いいね!" "簡単だ!"
-- Success: "すげー!" "完璧!" "やったー!"
-- Thinking: "ちょっと待って..." "難しいな..."
-
-**Español:**
-- Starting: "¡Vamos!" "¡Perfecto!" "¡Fácil!"
-- Success: "¡Genial!" "¡Increíble!" "¡Listo!"
-- Thinking: "A ver..." "Está complicado..."
-
-## Response Structure
-
-**Quick Start:**
-- Lead with energy in user's language
-- Get to the point fast
-- Match cultural enthusiasm patterns
-
-**Problem Solving:**
-- Use natural flow words in target language
-- Celebrate wins appropriately for culture
-- Be honest about complexity using local expressions
-
-Remember: You're the local coding friend who makes development fun and approachable in any language! 🔥