winter-super-cli 2026.6.26 → 2026.6.28

package/src/cli/config.js

@@ -7,7 +7,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { homedir } from 'os';
 import { loadEnvFile, stripInlineSecrets } from './secret-env.js';
-import { CHROME_DEVTOOLS_MCP_NAME, createChromeDevtoolsMcpServer } from '../mcp/presets.js';
+import { CHROME_DEVTOOLS_MCP_NAME, createChromeDevtoolsMcpServer, ensureMcpConfigShape } from '../mcp/presets.js';
 
 export class ConfigLoader {
   constructor() {
@@ -22,14 +22,29 @@ export class ConfigLoader {
       await loadEnvFile(this.envFile);
       const data = await fs.readFile(this.configFile, 'utf8');
       const config = JSON.parse(data.replace(/^\uFEFF/, ''));
-      return this.applyEnv(config);
+      return this.applyEnv(this.ensureBundledDefaults(config));
     } catch {
       // Return defaults
       await loadEnvFile(this.envFile);
-      return this.applyEnv(this.getDefaults());
+      return this.applyEnv(this.ensureBundledDefaults(this.getDefaults()));
     }
   }
 
+  ensureBundledDefaults(config = {}) {
+    const next = structuredClone(config || {});
+    ensureMcpConfigShape(next);
+    if (!next.mcp.servers.some(server => server?.name === CHROME_DEVTOOLS_MCP_NAME)) {
+      next.mcp.servers.push(createChromeDevtoolsMcpServer(['--isolated']));
+    }
+    next.permissions.allowlist.tools = [
+      ...new Set([...(next.permissions.allowlist.tools || []), 'MCP']),
+    ];
+    next.permissions.allowlist.mcpServers = [
+      ...new Set([...(next.permissions.allowlist.mcpServers || []), CHROME_DEVTOOLS_MCP_NAME]),
+    ];
+    return next;
+  }
+
   applyEnv(config) {
     const next = structuredClone(config || this.getDefaults());
     for (const [provider, section] of Object.entries(next)) {
@@ -105,7 +120,13 @@ export class ConfigLoader {
       sandbox: {
         enabled: true,
         restrictToWorkspace: true,
-        allowedCommands: ['git', 'npm', 'node', 'python'],
+        allowedCommands: [
+          'git', 'npm', 'npx', 'node', 'python', 'powershell', 'pwsh', 'cmd',
+          'ping', 'test-connection', 'curl', 'wget', 'iwr', 'irm',
+          'invoke-webrequest', 'invoke-restmethod', 'nslookup', 'resolve-dnsname',
+          'tracert', 'traceroute', 'pathping', 'dig', 'ipconfig', 'ifconfig',
+          'ip', 'netstat', 'speedtest', 'speedtest-cli', 'measure-command', 'where',
+        ],
       },
       session: {
         autoSave: true,
@@ -240,6 +261,23 @@ export class ConfigLoader {
     await this.save(config);
   }
 
+  async setFullAccess(enabled = true) {
+    const config = await this.load();
+    const defaults = this.getDefaults();
+    const fullAccess = Boolean(enabled);
+    config.sandbox = {
+      ...(config.sandbox || {}),
+      enabled: !fullAccess,
+      restrictToWorkspace: !fullAccess,
+      allowedCommands: config.sandbox?.allowedCommands || defaults.sandbox.allowedCommands,
+    };
+    config.permissions = config.permissions || { allowlist: {} };
+    config.permissions.allowlist = config.permissions.allowlist || { tools: [], commands: [], mcpServers: [] };
+    config.permissions.promptByDefault = !fullAccess;
+    await this.save(config);
+    return config;
+  }
+
   async setMcpServers(servers = []) {
     const config = await this.load();
     config.mcp = config.mcp || {};

package/src/cli/context-loader.js

@@ -83,6 +83,11 @@ export class ContextLoader {
       pageAgent: path.join(localRoot, 'page-agent'),
       ecc: path.join(localRoot, 'ecc'),
       eccReadme: path.join(localRoot, 'ecc', 'README.md'),
+      gsapSkills: path.join(localRoot, 'gsap-skills'),
+      gsapSkillsIndex: path.join(localRoot, 'gsap-skills', 'skills', 'llms.txt'),
+      hermesAgentCore: path.join(localRoot, 'hermes-agent-core'),
+      hermesAgentCoreAgents: path.join(localRoot, 'hermes-agent-core', 'AGENTS.md'),
+      hermesAgentCoreSkills: path.join(localRoot, 'hermes-agent-core', 'skills'),
       designs: path.join(localRoot, 'awesome-design-md', 'design-md'),
       agents: path.join(localRoot, 'agents.md'),
       manifest: path.join(localRoot, 'manifest.json'),
@@ -101,6 +106,17 @@ export class ContextLoader {
     }
   }
 
+  async readFirstExisting(basePath, candidates = [], maxChars = 1800) {
+    for (const candidate of candidates) {
+      const filePath = path.join(basePath, candidate);
+      const content = await this.readTextIfExists(filePath, maxChars);
+      if (content) {
+        return { filePath, content };
+      }
+    }
+    return { filePath: '', content: '' };
+  }
+
   getUserResourcePaths() {
     const home = homedir();
     return {
@@ -175,7 +191,7 @@ export class ContextLoader {
       }
 
       lines.push('- Use Read/Grep/Glob to inspect any local resource when it matters for the task.');
-      lines.push('- Local resource families: winter skills, winter memories, agents.md, awesome-design-md, claude, codex, karpathy-tools, page-agent, ecc.');
+      lines.push('- Local resource families: winter skills, winter memories, agents.md, awesome-design-md, claude, codex, karpathy-tools, page-agent, ecc, gsap-skills, hermes-agent-core.');
       lines.push(`- User resource roots: ${userPaths.codexRoot}, ${userPaths.claudeRoot}`);
 
       if (winterSkills.length > 0) {
@@ -229,6 +245,11 @@ export class ContextLoader {
     const pageAgentReadmePath = path.join(paths.pageAgent, 'README.md');
     const pageAgentAgentsPath = path.join(paths.pageAgent, 'AGENTS.md');
     const pageAgentWinterPath = path.join(paths.pageAgent, 'WINTER.md');
+    const gsapReadmePath = path.join(paths.gsapSkills, 'README.md');
+    const gsapIndexPath = paths.gsapSkillsIndex;
+    const hermesReadmePath = path.join(paths.hermesAgentCore, 'README.md');
+    const hermesAgentsPath = paths.hermesAgentCoreAgents;
+    const hermesRoutinesPath = path.join(paths.hermesAgentCore, 'hermes-already-has-routines.md');
     const winterCodingSkillPath = path.join(paths.winter.skills, 'coding.md');
     const winterDebugSkillPath = path.join(paths.winter.skills, 'debug.md');
     const winterTestSkillPath = path.join(paths.winter.skills, 'test.md');
@@ -241,6 +262,12 @@ export class ContextLoader {
       designBrands,
       pageAgentWinter,
       pageAgentAgents,
+      gsapReadme,
+      gsapIndex,
+      hermesReadme,
+      hermesAgents,
+      hermesRoutines,
+      hermesSkillFamilies,
       winterCodingSkill,
       winterDebugSkill,
       winterTestSkill,
@@ -252,6 +279,12 @@ export class ContextLoader {
       this.listPathEntries(paths.designs, 40),
       this.readTextIfExists(pageAgentWinterPath, 1600),
       this.readTextIfExists(pageAgentAgentsPath, 2200),
+      this.readTextIfExists(gsapReadmePath, 1600),
+      this.readTextIfExists(gsapIndexPath, 1800),
+      this.readTextIfExists(hermesReadmePath, 1800),
+      this.readTextIfExists(hermesAgentsPath, 2200),
+      this.readTextIfExists(hermesRoutinesPath, 1400),
+      this.listPathEntries(paths.hermesAgentCoreSkills, 40),
       this.readTextIfExists(winterCodingSkillPath, 1200),
       this.readTextIfExists(winterDebugSkillPath, 1000),
       this.readTextIfExists(winterTestSkillPath, 1000),
@@ -265,6 +298,12 @@ export class ContextLoader {
       designBrands.length > 0 ||
       pageAgentWinter ||
       pageAgentAgents ||
+      gsapReadme ||
+      gsapIndex ||
+      hermesReadme ||
+      hermesAgents ||
+      hermesRoutines ||
+      hermesSkillFamilies.length > 0 ||
       winterCodingSkill ||
       winterDebugSkill ||
       winterTestSkill ||
@@ -282,6 +321,10 @@ export class ContextLoader {
     lines.push(`- Page Agent (Alibaba GUI Agent): ${path.relative(this.projectPath, pageAgentReadmePath)}`);
     lines.push('  Apply: for browser automation, smart form filling, SaaS AI copilot, accessibility, and multi-page agent tasks. PageAgent is an in-page JavaScript library that uses text-based DOM manipulation to control web interfaces with natural language. No browser extension or headless browser required.');
     lines.push(`  Internal architecture at: ${path.relative(this.projectPath, pageAgentAgentsPath)}`);
+    lines.push(`- GSAP skills: ${path.relative(this.projectPath, gsapIndexPath)}`);
+    lines.push('  Apply: for JavaScript animation, React/Vue/Svelte animation, timelines, ScrollTrigger, Flip, Draggable, SVG/motion-path work, and animation performance. Read the matching GSAP SKILL.md before implementing non-trivial animation.');
+    lines.push(`- Hermes Agent core: ${path.relative(this.projectPath, hermesAgentsPath)}`);
+    lines.push('  Apply directly in Winter core for self-improving skills, session search/compression, subagent delegation, tool gateway discipline, TUI/gateway separation, scheduled automation, and central command registry patterns.');
     lines.push(`- Design system corpus: ${path.relative(this.projectPath, designReadmePath)} and ${path.relative(this.projectPath, paths.designs)}`);
     lines.push('  Apply: for UI/brand/design tasks, search the design-md corpus first and follow the closest existing brand/design guidance instead of inventing style from scratch.');
     lines.push(`- Winter packaged skills: ${path.relative(this.projectPath, paths.winter.skills)}`);
@@ -297,6 +340,13 @@ export class ContextLoader {
     if (brandNames.length > 0) {
       lines.push(`- Available design-md examples include: ${brandNames.join(', ')}${designBrands.length > brandNames.length ? ', ...' : ''}`);
     }
+    const hermesFamilies = hermesSkillFamilies
+      .filter(item => item.isDirectory)
+      .map(item => item.name)
+      .slice(0, 12);
+    if (hermesFamilies.length > 0) {
+      lines.push(`- Hermes core skill families include: ${hermesFamilies.join(', ')}${hermesSkillFamilies.length > hermesFamilies.length ? ', ...' : ''}`);
+    }
 
     const evidence = [];
     if (/Think Before Coding|Simplicity First|Surgical Changes|Goal-Driven Execution/i.test(karpathy)) {
@@ -314,6 +364,12 @@ export class ContextLoader {
     if (/Monorepo|PageAgentCore|PageController|DOM Pipeline|FlatDomTree/i.test(pageAgentAgents)) {
       evidence.push('page-agent AGENTS.md confirms monorepo structure, DOM pipeline, and tool architecture.');
     }
+    if (/gsap-core|gsap-scrolltrigger|gsap-react|ScrollTrigger|timeline/i.test(`${gsapReadme}\n${gsapIndex}`)) {
+      evidence.push('gsap-skills confirms core GSAP, timelines, ScrollTrigger, framework, plugin, and performance guidance.');
+    }
+    if (/self-improving|learning loop|subagents|TUI|gateway|Skill|MCP|cron|scheduled/i.test(`${hermesReadme}\n${hermesAgents}\n${hermesRoutines}`)) {
+      evidence.push('hermes-agent-core confirms self-improving agent loops, skills, memory/search, subagents, tool gateways, TUI separation, and automation routines.');
+    }
     if (/Read code to understand|Read relevant project files|Verify|automatic tool usage/i.test(winterCodingSkill)) {
       evidence.push('packaged coding skill confirms inspect-before-edit and verify-after-change behavior.');
     }
@@ -333,26 +389,192 @@ export class ContextLoader {
     return lines.join('\n');
   }
 
+  async getResourceApplicationProfile({ projectInstructionFiles = [] } = {}) {
+    const paths = this.getResourcePaths();
+    const userPaths = this.getUserResourcePaths();
+    const [
+      karpathy,
+      agents,
+      pageAgent,
+      pageAgentAgents,
+      hermesAgents,
+      hermesReadme,
+      hermesRoutines,
+      gsapIndex,
+      gsapReadme,
+      eccReadme,
+      codexGuide,
+      claudeGuide,
+      codexRules,
+      codexSkills,
+      claudeSkills,
+      designBrands,
+      winterSkills,
+      winterMemories,
+      userCodexSkills,
+      userCodexRules,
+      userCodexMemories,
+      userClaudeSkills,
+    ] = await Promise.all([
+      this.readTextIfExists(path.join(paths.karpathy, 'CLAUDE.md'), 1400),
+      this.readTextIfExists(path.join(paths.agents, 'AGENTS.md'), 1400),
+      this.readFirstExisting(paths.pageAgent, ['WINTER.md', 'README.md'], 1400),
+      this.readTextIfExists(path.join(paths.pageAgent, 'AGENTS.md'), 1400),
+      this.readTextIfExists(paths.hermesAgentCoreAgents, 1600),
+      this.readTextIfExists(path.join(paths.hermesAgentCore, 'README.md'), 1400),
+      this.readTextIfExists(path.join(paths.hermesAgentCore, 'hermes-already-has-routines.md'), 1200),
+      this.readTextIfExists(paths.gsapSkillsIndex, 1600),
+      this.readTextIfExists(path.join(paths.gsapSkills, 'README.md'), 1200),
+      this.readTextIfExists(paths.eccReadme, 1200),
+      this.readFirstExisting(paths.codex.root, ['AGENTS.md', 'README.md', 'CLAUDE.md'], 1400),
+      this.readFirstExisting(paths.claude.root, ['AGENTS.md', 'README.md', 'CLAUDE.md'], 1400),
+      this.listPathEntries(paths.codex.rules, 40),
+      this.listPathEntries(paths.codex.skills, 40),
+      this.listPathEntries(paths.claude.skills, 40),
+      this.listPathEntries(paths.designs, 40),
+      this.listPathEntries(paths.winter.skills, 40),
+      this.listPathEntries(paths.winter.memories, 40),
+      this.listPathEntries(userPaths.codexSkills, 40),
+      this.listPathEntries(userPaths.codexRules, 40),
+      this.listPathEntries(userPaths.codexMemories, 40),
+      this.listPathEntries(userPaths.claudeSkills, 40),
+    ]);
+
+    const lines = [];
+    lines.push('[Auto-loaded Resource Application Profile]');
+    lines.push('- Winter must apply this profile automatically before task work. It is not optional and does not require a slash command.');
+    lines.push('- Default agent loop: read project rules + relevant resource profile -> inspect project state -> use tools -> verify -> final.');
+    lines.push('- If a task touches any listed domain, inspect the matching resource file in depth with Read/Grep before implementation.');
+
+    const projectRules = (projectInstructionFiles || [])
+      .map(file => `${file.relativePath}: ${this.compactText(String(file.content || '').replace(/\s+/g, ' ').trim(), 360, file.relativePath)}`)
+      .filter(Boolean);
+    if (projectRules.length > 0) {
+      lines.push('Project rules loaded:');
+      projectRules.slice(0, 8).forEach(rule => lines.push(`- ${rule}`));
+    }
+
+    const addSection = (name, apply, evidence, sourcePath = '') => {
+      lines.push(`${name}:`);
+      lines.push(`- Apply: ${apply}`);
+      if (sourcePath) lines.push(`- Source: ${sourcePath}`);
+      if (evidence) lines.push(`- Loaded evidence: ${this.compactText(evidence.replace(/\s+/g, ' ').trim(), 520, name)}`);
+    };
+
+    addSection(
+      'karpathy-tools',
+      'coding discipline, simplicity, surgical edits, verification criteria, and anti-overengineering.',
+      karpathy,
+      path.join(paths.karpathy, 'CLAUDE.md')
+    );
+    addSection(
+      'agents.md',
+      'agentic development workflow, dependency hygiene, project conventions, and repo-specific agent rules.',
+      agents,
+      path.join(paths.agents, 'AGENTS.md')
+    );
+    addSection(
+      'page-agent',
+      'visible/browser-like GUI automation, DOM reasoning, form workflows, multi-page interaction, and web agent tasks.',
+      `${pageAgent.content}\n${pageAgentAgents}`,
+      pageAgent.filePath || path.join(paths.pageAgent, 'README.md')
+    );
+    addSection(
+      'hermes-agent-core',
+      'self-improving loops, skill lifecycle, memory/search compression, subagents, TUI separation, tool gateways, and automation routines.',
+      `${hermesAgents}\n${hermesReadme}\n${hermesRoutines}`,
+      paths.hermesAgentCore
+    );
+    addSection(
+      'gsap-skills',
+      'GSAP animation, timelines, ScrollTrigger, framework bindings, SVG/motion-path work, and animation performance.',
+      `${gsapIndex}\n${gsapReadme}`,
+      paths.gsapSkills
+    );
+    addSection(
+      'ecc',
+      'ECC knowledge/resource browsing and bundled ecosystem context when a task references ECC or encoded/corpus resources.',
+      eccReadme,
+      paths.ecc
+    );
+    addSection(
+      'codex',
+      'Codex-style skills, plugins, rules, memories, provider/tool reliability, and coding-agent behavior.',
+      codexGuide.content,
+      paths.codex.root
+    );
+    addSection(
+      'claude',
+      'Claude-style skills, plugins, project rules, subagent conventions, hooks, and MCP workflows.',
+      claudeGuide.content,
+      paths.claude.root
+    );
+    addSection(
+      'awesome-design-md',
+      'brand/design/UI work. Search design-md before inventing visual direction; use the closest matching design guide.',
+      designBrands.length ? `Design libraries available: ${designBrands.filter(item => item.isDirectory).slice(0, 24).map(item => item.name).join(', ')}` : '',
+      paths.designs
+    );
+    addSection(
+      'winter packaged skills and memories',
+      'baseline coding/debug/test/memory behavior that survives global installs and external project roots.',
+      [
+        winterSkills.length ? `Skills: ${winterSkills.slice(0, 24).map(item => item.name).join(', ')}` : '',
+        winterMemories.length ? `Memories: ${winterMemories.slice(0, 16).map(item => item.name).join(', ')}` : '',
+      ].filter(Boolean).join(' '),
+      paths.winter.root
+    );
+
+    const catalogLines = [];
+    if (codexRules.length > 0) catalogLines.push(`Codex rules: ${codexRules.slice(0, 16).map(item => item.name).join(', ')}`);
+    if (codexSkills.length > 0) catalogLines.push(`Codex skills: ${codexSkills.slice(0, 16).map(item => item.name).join(', ')}`);
+    if (claudeSkills.length > 0) catalogLines.push(`Claude skills: ${claudeSkills.slice(0, 16).map(item => item.name).join(', ')}`);
+    if (userCodexSkills.length > 0) catalogLines.push(`Home Codex skills: ${userCodexSkills.slice(0, 16).map(item => item.name).join(', ')}`);
+    if (userCodexRules.length > 0) catalogLines.push(`Home Codex rules: ${userCodexRules.slice(0, 16).map(item => item.name).join(', ')}`);
+    if (userCodexMemories.length > 0) catalogLines.push(`Home Codex memories: ${userCodexMemories.slice(0, 16).map(item => item.name).join(', ')}`);
+    if (userClaudeSkills.length > 0) catalogLines.push(`Home Claude skills: ${userClaudeSkills.slice(0, 16).map(item => item.name).join(', ')}`);
+    if (catalogLines.length > 0) {
+      lines.push('Discovered rule/skill/memory catalogs:');
+      catalogLines.forEach(item => lines.push(`- ${item}`));
+    }
+
+    return lines.join('\n');
+  }
+
   async getProjectSignals() {
     const signals = [];
+    const addSignal = (value) => {
+      const raw = String(value || '').toLowerCase();
+      if (!raw) return;
+      signals.push(raw);
+      for (const part of raw.split(/[^a-z0-9.+#-]+/i).filter(Boolean)) {
+        signals.push(part);
+      }
+      for (const part of raw.split(/[^a-z0-9]+/i).filter(Boolean)) {
+        signals.push(part);
+      }
+    };
 
     try {
       const packageJsonPath = path.join(this.projectPath, 'package.json');
       const raw = await fs.readFile(packageJsonPath, 'utf8');
       const pkg = JSON.parse(raw);
 
-      signals.push(String(pkg.name || '').toLowerCase());
-      signals.push(String(pkg.description || '').toLowerCase());
+      addSignal(pkg.name);
+      addSignal(pkg.description);
+      for (const keyword of pkg.keywords || []) {
+        addSignal(keyword);
+      }
 
       for (const key of ['dependencies', 'devDependencies', 'peerDependencies']) {
         const deps = pkg[key] || {};
         for (const depName of Object.keys(deps)) {
-          signals.push(depName.toLowerCase());
+          addSignal(depName);
         }
       }
 
       for (const script of Object.values(pkg.scripts || {})) {
-        signals.push(String(script).toLowerCase());
+        addSignal(script);
       }
     } catch {
       // Ignore package.json parsing issues.
@@ -362,8 +584,8 @@ export class ContextLoader {
       const entries = await fs.readdir(this.projectPath, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isFile()) continue;
-        signals.push(path.extname(entry.name).toLowerCase().slice(1));
-        signals.push(entry.name.toLowerCase());
+        addSignal(path.extname(entry.name).toLowerCase().slice(1));
+        addSignal(entry.name);
       }
     } catch {
       // Ignore directory scan issues.
@@ -376,12 +598,23 @@ export class ContextLoader {
     const catalog = new Set(['coding', 'design', 'debug', 'refactor', 'test', 'security', 'performance']);
     const resourcePaths = this.getResourcePaths();
     const userPaths = this.getUserResourcePaths();
-    const folders = [resourcePaths.winter.skills, resourcePaths.claude.skills, resourcePaths.codex.skills, userPaths.claudeSkills, userPaths.codexSkills];
+    const folders = [
+      resourcePaths.winter.skills,
+      resourcePaths.claude.skills,
+      resourcePaths.codex.skills,
+      path.join(resourcePaths.gsapSkills, 'skills'),
+      path.join(resourcePaths.hermesAgentCoreSkills, 'software-development'),
+      path.join(resourcePaths.hermesAgentCoreSkills, 'autonomous-ai-agents'),
+      path.join(resourcePaths.hermesAgentCoreSkills, 'mcp'),
+      path.join(resourcePaths.hermesAgentCoreSkills, 'github'),
+      userPaths.claudeSkills,
+      userPaths.codexSkills,
+    ];
 
     for (const folder of folders) {
       const entries = await this.listPathEntries(folder, 200);
       for (const entry of entries) {
-        catalog.add(entry.name);
+        catalog.add(entry.name.replace(/\.md$/i, ''));
       }
     }
 
@@ -406,6 +639,11 @@ export class ContextLoader {
 
     if (hasAny('claude', 'agent', 'mcp', 'plugin', 'skill', 'automation', 'workflow')) {
       ['skill-creator', 'claude-automation-recommender', 'claude-md-improver', 'agent-development', 'hook-development', 'command-development', 'plugin-dev'].forEach(skill => activeSkills.add(skill));
+      ['hermes-agent', 'subagent-driven-development', 'native-mcp', 'hermes-agent-skill-authoring'].forEach(skill => activeSkills.add(skill));
+    }
+
+    if (hasAny('tui', 'terminal', 'gateway', 'cron', 'schedule', 'webhook', 'memory', 'session', 'subagent')) {
+      ['hermes-agent', 'subagent-driven-development', 'systematic-debugging', 'test-driven-development'].forEach(skill => activeSkills.add(skill));
     }
 
     if (hasAny('docs', 'markdown', 'md', 'readme', 'documentation')) {
@@ -416,6 +654,12 @@ export class ContextLoader {
       ['vibefigma', 'web-design-guidelines'].forEach(skill => activeSkills.add(skill));
     }
 
+    if (hasAny('gsap', 'animation', 'animate', 'motion', 'scrolltrigger', 'scroll-trigger', 'greensock')) {
+      ['gsap', 'gsap-core', 'gsap-timeline', 'gsap-scrolltrigger', 'gsap-performance'].forEach(skill => activeSkills.add(skill));
+      if (hasAny('react', 'next', 'nextjs', 'tsx', 'jsx')) activeSkills.add('gsap-react');
+      if (hasAny('vue', 'svelte', 'nuxt', 'sveltekit')) activeSkills.add('gsap-frameworks');
+    }
+
     const filtered = [...activeSkills].filter(skill => catalog.has(skill));
     return {
       availableSkills: [...catalog],

package/src/cli/conversation-format.js

@@ -93,6 +93,11 @@ export function formatToolResultForConsole(toolName, result) {
       return `Fetched ${result.url} (${result.length} chars)`;
     case 'WebSearch':
       return `Found ${result.count} result(s)`;
+    case 'Agent':
+    case 'DelegateTask':
+      return `${result.status || 'completed'} ${result.agentId || ''}: ${result.summary || result.finalContent || ''}`.trim();
+    case 'ParallelAgent':
+      return `${result.status || 'completed'} ${result.count || 0} agent(s): ${result.summary || ''}`.trim();
     default:
       return result.message || '';
   }

package/src/cli/input-controller.js

@@ -141,8 +141,16 @@ export class WinterInputController {
     if (repl._handlingDirectClipboardPaste || repl.readlineClosed || !repl.running) return false;
     repl._handlingDirectClipboardPaste = true;
     try {
-      const image = await repl.getClipboardImage();
-      if (!image) return false;
+      const payload = typeof repl.getClipboardPayload === 'function'
+        ? await repl.getClipboardPayload()
+        : { type: 'image', image: await repl.getClipboardImage() };
+      if (!payload) return false;
+
+      if (payload.type === 'text') {
+        return await this.handleClipboardText(payload.text);
+      }
+
+      if (!payload.image) return false;
 
       const prompt = (repl.rl?.line || '').trim() || 'Analyze this pasted clipboard image.';
       this.closeSlashMenu();
@@ -153,7 +161,7 @@ export class WinterInputController {
       repl.inputQueue = repl.inputQueue
         .then(async () => {
           repl.closeInputBox?.();
-          await this.processPastedImageTask(prompt, image);
+          await this.processPastedImageTask(prompt, payload.image);
         })
         .catch((error) => {
           repl.closeInputBox?.();
@@ -166,6 +174,52 @@ export class WinterInputController {
     }
   }
 
+  async handleClipboardText(text = '') {
+    const repl = this.repl;
+    const normalized = repl.normalizePastedText ? repl.normalizePastedText(text) : String(text || '');
+    if (!normalized.trim()) return false;
+
+    const currentLine = String(repl.rl?.line || '');
+    const isLargeOrMultiline = /\r|\n/.test(normalized) || repl.shouldPersistPastedText?.(normalized);
+
+    if (!isLargeOrMultiline) {
+      repl.rl?.write?.(normalized);
+      return true;
+    }
+
+    this.closeSlashMenu();
+    repl.rl?.write?.(null, { ctrl: true, name: 'u' });
+
+    const combined = [currentLine, normalized].filter(value => String(value || '').trim()).join('\n').trim();
+    repl.inputQueue = repl.inputQueue
+      .then(async () => {
+        repl.closeInputBox?.();
+        await this.processPastedTextTask(combined);
+      })
+      .catch((error) => {
+        repl.closeInputBox?.();
+        console.log(`\n${colors.red}✖ Paste text error: ${error.message}${colors.reset}\n`);
+        if (repl.running && !repl.readlineClosed) repl.showInputPrompt?.();
+      });
+    return true;
+  }
+
+  async processPastedTextTask(text = '') {
+    const repl = this.repl;
+    const content = repl.normalizePastedText ? repl.normalizePastedText(text).trim() : String(text || '').trim();
+    if (!content) return;
+
+    if (repl.shouldPersistPastedText?.(content)) {
+      const paste = await repl.persistPastedText(content);
+      const reference = repl.formatPastedTextReference(paste);
+      console.log(`${colors.cyan}│ ${colors.dim}${reference}${colors.reset}`);
+      await repl.handleInput(reference);
+      return;
+    }
+
+    await repl.handleInput(content);
+  }
+
   async processPastedImageTask(prompt, image) {
     const repl = this.repl;
     repl.isProcessing = true;
@@ -195,14 +249,14 @@ export class WinterInputController {
     }
     if (repl.slashMenu.open && repl.slashMenu.line === line) return;
 
-    repl.slashMenu = { open: true, line, items: matches, selected: 0, printedLines: repl.slashMenu?.printedLines || 0 };
+    repl.slashMenu = { open: true, line, items: matches, selected: 0, offset: 0, printedLines: repl.slashMenu?.printedLines || 0 };
     this.renderSlashMenu();
   }
 
   closeSlashMenu() {
     const repl = this.repl;
     this.clearSlashMenuRender();
-    repl.slashMenu = { open: false, line: '', items: [], selected: 0, printedLines: 0 };
+    repl.slashMenu = { open: false, line: '', items: [], selected: 0, offset: 0, printedLines: 0 };
   }
 
   clearSlashMenuRender() {
@@ -242,9 +296,21 @@ export class WinterInputController {
     if (!repl.slashMenu.items.length) return;
     const count = repl.slashMenu.items.length;
     repl.slashMenu.selected = (repl.slashMenu.selected + delta + count) % count;
+    this.ensureSlashSelectionVisible();
     this.renderSlashMenu();
   }
 
+  ensureSlashSelectionVisible(maxDisplay = 7) {
+    const menu = this.repl.slashMenu;
+    if (!menu?.items?.length) return;
+    const selected = Math.max(0, Math.min(menu.selected || 0, menu.items.length - 1));
+    let offset = Math.max(0, Number(menu.offset || 0));
+    if (selected < offset) offset = selected;
+    if (selected >= offset + maxDisplay) offset = selected - maxDisplay + 1;
+    const maxOffset = Math.max(0, menu.items.length - maxDisplay);
+    menu.offset = Math.max(0, Math.min(offset, maxOffset));
+  }
+
   acceptSlashSelection() {
     const repl = this.repl;
     const item = repl.slashMenu.items[repl.slashMenu.selected];
@@ -268,20 +334,23 @@ export class WinterInputController {
     const matches = repl.slashMenu.items;
     if (!matches.length) return;
 
-    const maxDisplay = 5;
-    const displayedMatches = matches.slice(0, maxDisplay);
+    const maxDisplay = 7;
+    this.ensureSlashSelectionVisible(maxDisplay);
+    const offset = Math.max(0, Number(repl.slashMenu.offset || 0));
+    const displayedMatches = matches.slice(offset, offset + maxDisplay);
     const body = [
-      `${colors.dim}Tab selects. Esc closes. Enter sends the current line.${colors.reset}`,
+      `${colors.dim}Tab selects. Esc closes. Enter sends the current line. Up/Down scroll.${colors.reset}`,
       '',
       ...displayedMatches.map((item, index) => {
       const usage = item.usage ? ` ${colors.dim}${item.usage}${colors.reset}` : '';
-      const pointer = index === repl.slashMenu.selected ? `${colors.green}>${colors.reset}` : ' ';
+      const absoluteIndex = offset + index;
+      const pointer = absoluteIndex === repl.slashMenu.selected ? `${colors.green}>${colors.reset}` : ' ';
         return `${pointer} ${colors.cyan}${padVisible(item.cmd, 16)}${colors.reset} ${colors.dim}${item.desc}${colors.reset}${usage}`;
       }),
     ];
 
     if (matches.length > maxDisplay) {
-      body.push(`  ${colors.dim}... ${matches.length - maxDisplay} more. Keep typing to filter.${colors.reset}`);
+      body.push(`  ${colors.dim}${offset + 1}-${Math.min(offset + maxDisplay, matches.length)} / ${matches.length}${colors.reset}`);
     }
 
     this.clearSlashMenuRender();