@heysalad/cheri-cli 0.8.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heysalad/cheri-cli",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Cheri CLI - AI-powered cloud IDE by HeySalad. Like Claude Code, but for cloud workspaces.",
   "type": "module",
   "bin": {

package/src/commands/agent.js

@@ -1,6 +1,12 @@
 import { apiClient } from "../lib/api-client.js";
 import { log } from "../lib/logger.js";
-import { getToolDefinitions, executeTool as executeLocalTool, requiresConfirmation } from "../lib/tools/index.js";
+import { getToolDefinitions, executeTool as executeLocalTool, requiresConfirmation as toolRequiresConfirmation } from "../lib/tools/index.js";
+import { generateSessionId, saveSession, loadSession, listSessions } from "../lib/sessions/index.js";
+import { compactMessages, shouldCompact, estimateMessagesTokens } from "../lib/context.js";
+import { loadHooks, runHooks } from "../lib/hooks/index.js";
+import { loadPlugins, getSkillContext, getSlashCommand } from "../lib/plugins/index.js";
+import { checkPermission, loadPermissions } from "../lib/permissions.js";
+import { getMemoryContext } from "../lib/memory.js";
 import chalk from "chalk";
 import readline from "readline";
 
@@ -20,7 +26,7 @@ Guidelines:
 - Never guess file contents — always read first.
 - Current working directory: ${process.cwd()}`;
 
-// Cloud platform tools (executed via API)
+// Cloud platform tools
 const CLOUD_TOOLS = [
   { name: "get_account_info", description: "Get the current user's account information", parameters: { type: "object", properties: {}, required: [] } },
   { name: "list_workspaces", description: "List all cloud workspaces for the current user", parameters: { type: "object", properties: {}, required: [] } },
@@ -37,7 +43,6 @@ const CLOUD_TOOLS = [
 
 const CLOUD_TOOL_NAMES = new Set(CLOUD_TOOLS.map((t) => t.name));
 
-// Build unified tool list in OpenAI function-calling format
 function buildTools() {
   const localDefs = getToolDefinitions().map((t) => ({
     type: "function",
@@ -50,7 +55,6 @@ function buildTools() {
   return [...localDefs, ...cloudDefs];
 }
 
-// Execute a cloud platform tool via the API
 async function executeCloudTool(name, args) {
   try {
     switch (name) {
@@ -79,36 +83,48 @@ async function executeCloudTool(name, args) {
   }
 }
 
-// Ask user for confirmation before destructive operations
 async function confirmAction(toolName, input) {
   const desc = toolName === "run_command" ? input.command : JSON.stringify(input);
   return new Promise((resolve) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question(chalk.yellow(`  Allow ${chalk.cyan(toolName)}: ${chalk.dim(desc)}? [Y/n] `), (answer) => {
+    rl.question(chalk.yellow(`  Allow ${chalk.cyan(toolName)}: ${chalk.dim(truncate(desc, 60))}? [Y/n] `), (answer) => {
       rl.close();
       resolve(answer.trim().toLowerCase() !== "n");
     });
   });
 }
 
-// Unified tool executor
 async function executeTool(name, args) {
+  // Check permission rules
+  const permission = checkPermission(name, args);
+  if (permission === "deny") {
+    return { error: `Tool ${name} is denied by permission rules` };
+  }
+
+  // Run PreToolUse hooks
+  const hookResult = await runHooks("PreToolUse", { toolName: name, input: args });
+  if (!hookResult.allowed) {
+    return { error: hookResult.reason || `Blocked by hook` };
+  }
+
+  // Cloud tools
   if (CLOUD_TOOL_NAMES.has(name)) {
-    return executeCloudTool(name, args);
+    const result = await executeCloudTool(name, args);
+    await runHooks("PostToolUse", { toolName: name, input: args, result });
+    return result;
   }
 
-  // Local tool — check if it needs confirmation
-  if (requiresConfirmation(name)) {
+  // Local tools — check if confirmation needed
+  if (permission === "ask" || (permission !== "allow" && toolRequiresConfirmation(name))) {
     const allowed = await confirmAction(name, args);
-    if (!allowed) {
-      return { error: "User denied execution" };
-    }
+    if (!allowed) return { error: "User denied execution" };
   }
 
-  return executeLocalTool(name, args);
+  const result = await executeLocalTool(name, args);
+  await runHooks("PostToolUse", { toolName: name, input: args, result });
+  return result;
 }
 
-// Parse SSE stream from the cloud proxy
 async function* parseSSEStream(response) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
@@ -127,9 +143,7 @@ async function* parseSSEStream(response) {
         if (line.startsWith("data: ")) {
           const data = line.slice(6).trim();
           if (data === "[DONE]") return;
-          try {
-            yield JSON.parse(data);
-          } catch {}
+          try { yield JSON.parse(data); } catch {}
         }
       }
     }
@@ -138,18 +152,108 @@ async function* parseSSEStream(response) {
   }
 }
 
-export async function runAgent(userRequest) {
-  const ALL_TOOLS = buildTools();
+// Active session state
+let currentSession = null;
+
+export async function runAgent(userRequest, options = {}) {
+  // Initialize systems
+  loadHooks();
+  loadPermissions();
+  const plugins = loadPlugins();
+  const memoryContext = getMemoryContext();
+  const skillContext = getSkillContext(plugins.skills, userRequest);
+
+  // Check for slash commands
+  if (userRequest.startsWith("/")) {
+    const cmdName = userRequest.slice(1).split(/\s+/)[0];
+    const cmdArgs = userRequest.slice(1 + cmdName.length).trim();
+
+    // Built-in slash commands
+    if (cmdName === "sessions" || cmdName === "history") {
+      const sessions = listSessions();
+      if (sessions.length === 0) { log.info("No saved sessions."); return; }
+      log.brand("Sessions");
+      sessions.slice(0, 10).forEach((s) => {
+        console.log(`  ${chalk.dim(s.id.slice(0, 12))}  ${s.title}  ${chalk.dim(`(${s.messageCount} msgs)`)}`);
+      });
+      return;
+    }
+    if (cmdName === "resume") {
+      const sessions = listSessions();
+      if (sessions.length === 0) { log.info("No sessions to resume."); return; }
+      const target = cmdArgs ? sessions.find((s) => s.id.includes(cmdArgs)) : sessions[0];
+      if (!target) { log.error("Session not found."); return; }
+      const data = loadSession(target.id);
+      if (data) {
+        currentSession = { id: target.id, messages: data.messages, title: data.title };
+        log.success(`Resumed session: ${target.title}`);
+        log.dim(`${data.messages.length} messages loaded`);
+      }
+      return;
+    }
+    if (cmdName === "compact") {
+      if (!currentSession) { log.info("No active session to compact."); return; }
+      const before = estimateMessagesTokens(currentSession.messages);
+      const { messages } = compactMessages(currentSession.messages, 50000);
+      currentSession.messages = messages;
+      const after = estimateMessagesTokens(messages);
+      log.success(`Compacted: ~${Math.round(before / 1000)}k → ~${Math.round(after / 1000)}k tokens`);
+      return;
+    }
+    if (cmdName === "new") {
+      currentSession = null;
+      log.success("Started new session.");
+      return;
+    }
 
-  const messages = [
-    { role: "system", content: SYSTEM_PROMPT },
-    { role: "user", content: userRequest },
-  ];
+    // Plugin slash commands
+    const cmd = getSlashCommand(plugins.commands, cmdName);
+    if (cmd) {
+      log.info(`Running /${cmdName}`);
+      userRequest = cmd.content.replace(/\$ARGUMENTS/g, cmdArgs).replace(/\$1/g, cmdArgs);
+    }
+  }
+
+  // Run SessionStart hooks on first message
+  if (!currentSession) {
+    await runHooks("SessionStart", { cwd: process.cwd() });
+  }
+
+  // Build or continue session
+  if (!currentSession) {
+    currentSession = {
+      id: generateSessionId(),
+      messages: [{ role: "system", content: SYSTEM_PROMPT + memoryContext + skillContext }],
+      title: userRequest.slice(0, 60),
+      createdAt: Date.now(),
+    };
+  } else {
+    // Inject fresh skill context if relevant
+    if (skillContext) {
+      const sysMsg = currentSession.messages.find((m) => m.role === "system");
+      if (sysMsg && !sysMsg.content.includes(skillContext)) {
+        sysMsg.content += skillContext;
+      }
+    }
+  }
 
+  currentSession.messages.push({ role: "user", content: userRequest });
+  currentSession.updatedAt = Date.now();
+
+  // Auto-compact if conversation is too long
+  if (shouldCompact(currentSession.messages)) {
+    const { messages, compacted } = compactMessages(currentSession.messages);
+    if (compacted) {
+      currentSession.messages = messages;
+      log.dim("Context auto-compacted to fit window.");
+    }
+  }
+
+  const ALL_TOOLS = buildTools();
   const MAX_ITERATIONS = 15;
 
   for (let i = 0; i < MAX_ITERATIONS; i++) {
-    const response = await apiClient.chatStream(messages, ALL_TOOLS);
+    const response = await apiClient.chatStream(currentSession.messages, ALL_TOOLS);
 
     let fullText = "";
     const toolCalls = {};
@@ -166,9 +270,7 @@ export async function runAgent(userRequest) {
       if (delta?.tool_calls) {
         for (const tc of delta.tool_calls) {
           const idx = tc.index;
-          if (!toolCalls[idx]) {
-            toolCalls[idx] = { id: tc.id || "", name: "", arguments: "" };
-          }
+          if (!toolCalls[idx]) toolCalls[idx] = { id: tc.id || "", name: "", arguments: "" };
           if (tc.id) toolCalls[idx].id = tc.id;
           if (tc.function?.name) toolCalls[idx].name = tc.function.name;
           if (tc.function?.arguments) toolCalls[idx].arguments += tc.function.arguments;
@@ -180,24 +282,22 @@ export async function runAgent(userRequest) {
 
     const toolCallList = Object.values(toolCalls);
 
-    // No tool calls — final text response, done
     if (toolCallList.length === 0) {
       if (fullText) process.stdout.write("\n");
+      // Save assistant response to session
+      currentSession.messages.push({ role: "assistant", content: fullText });
+      saveSession(currentSession.id, currentSession);
       return;
     }
 
     if (fullText) process.stdout.write("\n");
 
-    // Build assistant message with tool calls
     const assistantMsg = { role: "assistant", content: fullText || null };
     assistantMsg.tool_calls = toolCallList.map((tc) => ({
-      id: tc.id,
-      type: "function",
-      function: { name: tc.name, arguments: tc.arguments },
+      id: tc.id, type: "function", function: { name: tc.name, arguments: tc.arguments },
     }));
-    messages.push(assistantMsg);
+    currentSession.messages.push(assistantMsg);
 
-    // Execute each tool and add results
     for (const tc of toolCallList) {
       let input = {};
       try { input = JSON.parse(tc.arguments); } catch {}
@@ -214,19 +314,18 @@ export async function runAgent(userRequest) {
         log.success(tc.name);
       }
 
-      // Truncate large tool results to avoid blowing context
       const resultStr = JSON.stringify(result);
       const truncatedResult = resultStr.length > 8000 ? resultStr.slice(0, 8000) + "...(truncated)" : resultStr;
 
-      messages.push({
-        role: "tool",
-        tool_call_id: tc.id,
-        content: truncatedResult,
-      });
+      currentSession.messages.push({ role: "tool", tool_call_id: tc.id, content: truncatedResult });
     }
+
+    // Save session after each tool round
+    saveSession(currentSession.id, currentSession);
   }
 
   log.warn("Agent reached maximum iterations (15). Stopping.");
+  await runHooks("Stop", { reason: "max_iterations" });
 }
 
 function truncate(str, max) {
@@ -240,10 +339,7 @@ export function registerAgentCommand(program) {
     .description("AI coding agent — natural language command interface")
     .action(async (requestParts) => {
       const request = requestParts.join(" ");
-      try {
-        await runAgent(request);
-      } catch (err) {
-        log.error(err.message);
-      }
+      try { await runAgent(request); }
+      catch (err) { log.error(err.message); }
     });
 }

package/src/lib/context.js

@@ -0,0 +1,56 @@
+// Simple token estimation (~4 chars per token for English)
+function estimateTokens(text) {
+  return Math.ceil((text || "").length / 4);
+}
+
+export function estimateMessagesTokens(messages) {
+  return messages.reduce((sum, m) => {
+    const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content || "");
+    return sum + estimateTokens(content) + 4; // 4 tokens overhead per message
+  }, 0);
+}
+
+// Compress conversation by summarizing old tool results and trimming history
+export function compactMessages(messages, maxTokens = 100000) {
+  const currentTokens = estimateMessagesTokens(messages);
+  if (currentTokens <= maxTokens) return { messages, compacted: false };
+
+  const compacted = [];
+  const systemMsg = messages.find((m) => m.role === "system");
+  if (systemMsg) compacted.push(systemMsg);
+
+  // Keep recent messages (last 20), compress older ones
+  const nonSystem = messages.filter((m) => m.role !== "system");
+  const keepRecent = 20;
+  const old = nonSystem.slice(0, -keepRecent);
+  const recent = nonSystem.slice(-keepRecent);
+
+  if (old.length > 0) {
+    // Build a summary of old messages
+    const userMessages = old.filter((m) => m.role === "user" && typeof m.content === "string");
+    const toolResults = old.filter((m) => m.role === "tool");
+
+    let summary = "[Conversation history compacted]\n";
+    summary += `Previous turns: ${old.length} messages\n`;
+
+    if (userMessages.length > 0) {
+      summary += "Topics discussed:\n";
+      userMessages.forEach((m) => {
+        summary += `- ${m.content.slice(0, 100)}\n`;
+      });
+    }
+
+    summary += `Tool calls made: ${toolResults.length}\n`;
+
+    compacted.push({ role: "user", content: summary });
+    compacted.push({ role: "assistant", content: "Understood. I have context from the previous conversation. Let's continue." });
+  }
+
+  compacted.push(...recent);
+  return { messages: compacted, compacted: true };
+}
+
+// Check if we should auto-compact
+export function shouldCompact(messages, threshold = 80000) {
+  return estimateMessagesTokens(messages) > threshold;
+}

package/src/lib/hooks/index.js

@@ -0,0 +1,82 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+import { log } from "../logger.js";
+
+// Hook events: PreToolUse, PostToolUse, Stop, SessionStart, SessionEnd
+// Hooks are loaded from .cheri/hooks.json in the project directory
+
+const HOOKS_FILE = ".cheri/hooks.json";
+
+let loadedHooks = null;
+
+export function loadHooks(projectDir = process.cwd()) {
+  const hooksPath = join(projectDir, HOOKS_FILE);
+  if (!existsSync(hooksPath)) {
+    loadedHooks = {};
+    return loadedHooks;
+  }
+  try {
+    loadedHooks = JSON.parse(readFileSync(hooksPath, "utf-8"));
+  } catch {
+    loadedHooks = {};
+  }
+  return loadedHooks;
+}
+
+export function getHooks(event) {
+  if (!loadedHooks) loadHooks();
+  return loadedHooks[event] || [];
+}
+
+// Run hooks for an event. Returns { allowed: bool, reason?: string }
+export async function runHooks(event, context = {}) {
+  const hooks = getHooks(event);
+  if (hooks.length === 0) return { allowed: true };
+
+  for (const hook of hooks) {
+    // Check matcher
+    if (hook.matcher && context.toolName) {
+      const matchers = hook.matcher.split("|");
+      if (!matchers.some((m) => context.toolName.match(new RegExp(m)))) {
+        continue;
+      }
+    }
+
+    for (const h of hook.hooks || [hook]) {
+      try {
+        if (h.type === "command") {
+          const input = JSON.stringify(context);
+          const timeout = (h.timeout || 10) * 1000;
+          const result = execSync(h.command, {
+            input,
+            encoding: "utf-8",
+            timeout,
+            stdio: ["pipe", "pipe", "pipe"],
+            cwd: process.cwd(),
+          });
+
+          try {
+            const output = JSON.parse(result.trim());
+            if (output.decision === "block") {
+              return { allowed: false, reason: output.reason || "Blocked by hook" };
+            }
+          } catch {
+            // Non-JSON output is fine, treat as allow
+          }
+        }
+      } catch (err) {
+        if (err.status === 2) {
+          // Exit code 2 = block
+          return { allowed: false, reason: err.stderr || "Blocked by hook" };
+        }
+        // Exit code 1 = warn but allow
+        if (err.status === 1 && err.stderr) {
+          log.warn(`Hook: ${err.stderr.trim()}`);
+        }
+      }
+    }
+  }
+
+  return { allowed: true };
+}

package/src/lib/memory.js

@@ -0,0 +1,73 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// Memory scopes:
+// - user: ~/.cheri/memory.json (global, follows user)
+// - project: .cheri/memory.json (per-project, in git)
+// - local: .cheri/memory.local.json (per-project, gitignored)
+
+const USER_MEMORY_PATH = join(homedir(), ".cheri", "memory.json");
+const PROJECT_MEMORY_FILE = ".cheri/memory.json";
+const LOCAL_MEMORY_FILE = ".cheri/memory.local.json";
+
+function loadMemoryFile(filePath) {
+  if (!existsSync(filePath)) return [];
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+
+function saveMemoryFile(filePath, entries) {
+  const dir = join(filePath, "..");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, JSON.stringify(entries, null, 2), "utf-8");
+}
+
+export function getMemory(scope = "all", projectDir = process.cwd()) {
+  const memories = {};
+
+  if (scope === "all" || scope === "user") {
+    memories.user = loadMemoryFile(USER_MEMORY_PATH);
+  }
+  if (scope === "all" || scope === "project") {
+    memories.project = loadMemoryFile(join(projectDir, PROJECT_MEMORY_FILE));
+  }
+  if (scope === "all" || scope === "local") {
+    memories.local = loadMemoryFile(join(projectDir, LOCAL_MEMORY_FILE));
+  }
+
+  return memories;
+}
+
+export function addMemory(content, scope = "project", category = "general", projectDir = process.cwd()) {
+  const filePath = scope === "user" ? USER_MEMORY_PATH :
+    scope === "local" ? join(projectDir, LOCAL_MEMORY_FILE) :
+    join(projectDir, PROJECT_MEMORY_FILE);
+
+  const entries = loadMemoryFile(filePath);
+  entries.push({ content, category, scope, createdAt: new Date().toISOString() });
+  saveMemoryFile(filePath, entries);
+  return entries.length;
+}
+
+export function clearMemory(scope = "all", projectDir = process.cwd()) {
+  if (scope === "all" || scope === "user") saveMemoryFile(USER_MEMORY_PATH, []);
+  if (scope === "all" || scope === "project") saveMemoryFile(join(projectDir, PROJECT_MEMORY_FILE), []);
+  if (scope === "all" || scope === "local") saveMemoryFile(join(projectDir, LOCAL_MEMORY_FILE), []);
+}
+
+// Build memory context string for system prompt
+export function getMemoryContext(projectDir = process.cwd()) {
+  const all = getMemory("all", projectDir);
+  const entries = [...(all.user || []), ...(all.project || []), ...(all.local || [])];
+  if (entries.length === 0) return "";
+
+  let context = "\n\n## Memory\nThe following are remembered preferences and context:\n";
+  for (const entry of entries) {
+    context += `- [${entry.scope}/${entry.category}] ${entry.content}\n`;
+  }
+  return context;
+}

package/src/lib/permissions.js

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// Permission rules loaded from .cheri/permissions.json
+// Format: { "allow": ["read_file", "list_directory"], "ask": ["run_command", "write_file"], "deny": ["clear_memory"] }
+// Bash patterns: "run_command(npm:*)" allows npm commands
+
+const PERMISSIONS_FILE = ".cheri/permissions.json";
+let rules = null;
+
+export function loadPermissions(projectDir = process.cwd()) {
+  const filePath = join(projectDir, PERMISSIONS_FILE);
+  if (!existsSync(filePath)) {
+    rules = { allow: [], ask: [], deny: [] };
+    return rules;
+  }
+  try {
+    rules = JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    rules = { allow: [], ask: [], deny: [] };
+  }
+  return rules;
+}
+
+export function checkPermission(toolName, input = {}) {
+  if (!rules) loadPermissions();
+
+  // Check deny first
+  for (const pattern of rules.deny || []) {
+    if (matchesPattern(toolName, input, pattern)) {
+      return "deny";
+    }
+  }
+
+  // Check allow
+  for (const pattern of rules.allow || []) {
+    if (matchesPattern(toolName, input, pattern)) {
+      return "allow";
+    }
+  }
+
+  // Check ask
+  for (const pattern of rules.ask || []) {
+    if (matchesPattern(toolName, input, pattern)) {
+      return "ask";
+    }
+  }
+
+  // Default: allow for read-only tools, ask for others
+  const readOnlyTools = ["read_file", "list_directory", "search_files", "search_content", "get_account_info", "list_workspaces", "get_memory", "get_usage", "get_config", "get_workspace_status"];
+  return readOnlyTools.includes(toolName) ? "allow" : "ask";
+}
+
+function matchesPattern(toolName, input, pattern) {
+  // Simple match: "read_file"
+  if (pattern === toolName) return true;
+
+  // Pattern match: "run_command(npm:*)"
+  const match = pattern.match(/^(\w+)\((.+)\)$/);
+  if (match && match[1] === toolName) {
+    const argPattern = match[2];
+    const command = input.command || "";
+    // Convert glob to regex
+    const regex = new RegExp("^" + argPattern.replace(/\*/g, ".*").replace(/:/g, "\\s*") + "$");
+    return regex.test(command);
+  }
+
+  return false;
+}

package/src/lib/plugins/index.js

@@ -0,0 +1,138 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join, resolve } from "path";
+import { log } from "../logger.js";
+
+const PLUGIN_DIR = ".cheri";
+const SKILLS_DIR = "skills";
+const COMMANDS_DIR = "commands";
+const AGENTS_DIR = "agents";
+
+// Load all plugins from .cheri/ directory
+export function loadPlugins(projectDir = process.cwd()) {
+  const cheriDir = join(projectDir, PLUGIN_DIR);
+  if (!existsSync(cheriDir)) return { skills: [], commands: [], agents: [] };
+
+  return {
+    skills: loadSkills(cheriDir),
+    commands: loadCommands(cheriDir),
+    agents: loadAgents(cheriDir),
+  };
+}
+
+// Load skills from .cheri/skills/
+function loadSkills(cheriDir) {
+  const skillsDir = join(cheriDir, SKILLS_DIR);
+  if (!existsSync(skillsDir)) return [];
+
+  const skills = [];
+  for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      const skillFile = join(skillsDir, entry.name, "SKILL.md");
+      if (existsSync(skillFile)) {
+        const parsed = parseMarkdownWithFrontmatter(readFileSync(skillFile, "utf-8"));
+        skills.push({
+          name: parsed.frontmatter.name || entry.name,
+          description: parsed.frontmatter.description || "",
+          trigger: parsed.frontmatter.trigger || "",
+          content: parsed.body,
+          dir: join(skillsDir, entry.name),
+        });
+      }
+    }
+  }
+  return skills;
+}
+
+// Load slash commands from .cheri/commands/
+function loadCommands(cheriDir) {
+  const commandsDir = join(cheriDir, COMMANDS_DIR);
+  if (!existsSync(commandsDir)) return [];
+
+  const commands = [];
+  for (const file of readdirSync(commandsDir)) {
+    if (file.endsWith(".md")) {
+      const content = readFileSync(join(commandsDir, file), "utf-8");
+      const parsed = parseMarkdownWithFrontmatter(content);
+      commands.push({
+        name: file.replace(".md", ""),
+        description: parsed.frontmatter.description || "",
+        allowedTools: parsed.frontmatter["allowed-tools"] || "",
+        content: parsed.body,
+      });
+    }
+  }
+  return commands;
+}
+
+// Load agent definitions from .cheri/agents/
+function loadAgents(cheriDir) {
+  const agentsDir = join(cheriDir, AGENTS_DIR);
+  if (!existsSync(agentsDir)) return [];
+
+  const agents = [];
+  for (const file of readdirSync(agentsDir)) {
+    if (file.endsWith(".md")) {
+      const content = readFileSync(join(agentsDir, file), "utf-8");
+      const parsed = parseMarkdownWithFrontmatter(content);
+      agents.push({
+        name: parsed.frontmatter.name || file.replace(".md", ""),
+        description: parsed.frontmatter.description || "",
+        model: parsed.frontmatter.model || "inherit",
+        tools: parsed.frontmatter.tools || [],
+        systemPrompt: parsed.body,
+      });
+    }
+  }
+  return agents;
+}
+
+// Parse markdown with YAML frontmatter (--- delimited)
+function parseMarkdownWithFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) return { frontmatter: {}, body: content };
+
+  const frontmatter = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx > 0) {
+      const key = line.slice(0, colonIdx).trim();
+      let value = line.slice(colonIdx + 1).trim();
+      // Parse arrays
+      if (value.startsWith("[") && value.endsWith("]")) {
+        try { value = JSON.parse(value); } catch {}
+      }
+      frontmatter[key] = value;
+    }
+  }
+
+  return { frontmatter, body: match[2].trim() };
+}
+
+// Get extra system prompt context from skills that match the user's request
+export function getSkillContext(skills, userMessage) {
+  const matched = [];
+  const lowerMsg = userMessage.toLowerCase();
+
+  for (const skill of skills) {
+    // Match by trigger keyword or description
+    const triggers = skill.trigger ? skill.trigger.split(",").map((t) => t.trim().toLowerCase()) : [];
+    const descWords = skill.description.toLowerCase().split(/\s+/);
+    const nameMatch = lowerMsg.includes(skill.name.toLowerCase());
+    const triggerMatch = triggers.some((t) => lowerMsg.includes(t));
+    const descMatch = descWords.filter((w) => w.length > 4).some((w) => lowerMsg.includes(w));
+
+    if (nameMatch || triggerMatch || descMatch) {
+      matched.push(skill);
+    }
+  }
+
+  if (matched.length === 0) return "";
+
+  return "\n\n## Active Skills\n" +
+    matched.map((s) => `### ${s.name}\n${s.content}`).join("\n\n");
+}
+
+// Execute a slash command
+export function getSlashCommand(commands, name) {
+  return commands.find((c) => c.name === name);
+}

package/src/lib/sessions/index.js

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const SESSIONS_DIR = join(homedir(), ".cheri", "sessions");
+
+function ensureDir() {
+  if (!existsSync(SESSIONS_DIR)) {
+    mkdirSync(SESSIONS_DIR, { recursive: true });
+  }
+}
+
+export function generateSessionId() {
+  return `s-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export function saveSession(sessionId, data) {
+  ensureDir();
+  const filePath = join(SESSIONS_DIR, `${sessionId}.json`);
+  writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+
+export function loadSession(sessionId) {
+  const filePath = join(SESSIONS_DIR, `${sessionId}.json`);
+  if (!existsSync(filePath)) return null;
+  return JSON.parse(readFileSync(filePath, "utf-8"));
+}
+
+export function listSessions() {
+  ensureDir();
+  const files = readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+  return files.map((f) => {
+    try {
+      const data = JSON.parse(readFileSync(join(SESSIONS_DIR, f), "utf-8"));
+      return {
+        id: f.replace(".json", ""),
+        title: data.title || data.messages?.[1]?.content?.slice(0, 60) || "Untitled",
+        messageCount: data.messages?.length || 0,
+        createdAt: data.createdAt,
+        updatedAt: data.updatedAt,
+      };
+    } catch {
+      return { id: f.replace(".json", ""), title: "Corrupted", messageCount: 0 };
+    }
+  }).sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+}
+
+export function deleteSession(sessionId) {
+  const filePath = join(SESSIONS_DIR, `${sessionId}.json`);
+  if (existsSync(filePath)) {
+    const { unlinkSync } = require("fs");
+    unlinkSync(filePath);
+    return true;
+  }
+  return false;
+}

package/src/repl.js

@@ -54,6 +54,11 @@ function showHelp() {
 }
 
 async function dispatch(input) {
+  // Strip "cheri " prefix if user types it inside the REPL
+  if (input.startsWith("cheri ")) {
+    input = input.slice(6);
+  }
+
   const parts = input.split(/\s+/);
   const cmd = parts[0];
   const sub = parts[1];
@@ -179,9 +184,16 @@ async function dispatch(input) {
       return;
     }
 
-    default:
+    default: {
       // Treat any unrecognized input as an agent request
+      const { getConfigValue } = await import("./lib/config-store.js");
+      const token = getConfigValue("token");
+      if (!token) {
+        log.warn("Not logged in. Type " + chalk.cyan("login") + " first to authenticate.");
+        return;
+      }
       await runAgent(input);
+    }
   }
 }