winter-super-cli 2026.6.24 → 2026.6.27

package/src/ai/capability-scorecard.js

@@ -1,4 +1,6 @@
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
+import { mkdtemp, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
@@ -73,8 +75,9 @@ export const CAPABILITY_AREAS = [
     target: 'Codebuff/Claude-style custom agents with scoped tools',
     probes: [
       { key: 'agentRegistry', label: 'project agent registry is active' },
-      { key: 'agentTool', label: 'Agent tool exists' },
-      { key: 'scopedTools', label: 'role-scoped tools are available' },
+      { key: 'agentTool', label: 'Agent tool runs real subagent conversations' },
+      { key: 'scopedTools', label: 'role-scoped tools are enforced' },
+      { key: 'processIsolation', label: 'subagents can run through child-process isolation' },
     ],
   },
   {
@@ -107,6 +110,7 @@ export const CAPABILITY_AREAS = [
     probes: [
       { key: 'autoDebug', label: '/debug and /auto routes exist' },
       { key: 'browserDebug', label: 'BrowserDebug tool exists' },
+      { key: 'browserSmoke', label: 'browser smoke covers BrowserDebug and VisibleBrowser' },
       { key: 'verificationCommands', label: 'verification command inference exists' },
     ],
   },
@@ -139,24 +143,197 @@ function scoreArea(area, probes) {
   };
 }
 
+async function runBehaviorProbes() {
+  const result = {
+    agentTool: false,
+    scopedTools: false,
+    processIsolation: false,
+    slashMenu: false,
+  };
+
+  try {
+    const { AgentTool } = await import('../tools/agent.js');
+    const definitions = [{ name: 'Read' }, { name: 'Write' }];
+    const repl = {
+      projectPath: PACKAGE_ROOT,
+      ai: {
+        getActiveProvider: () => 'probe',
+        setProvider: () => true,
+      },
+      tools: {
+        getToolDefinitions: () => definitions,
+      },
+      agentRegistry: {
+        async get(id = 'general') {
+          return { id, tools: ['Read'], instructionsPrompt: 'probe' };
+        },
+      },
+      getAgentToolsForDefinition(definition) {
+        return definitions.filter(tool => definition.tools.includes(tool.name));
+      },
+      async getProjectContext() {
+        return '';
+      },
+      getAgentDefinitionSystemPrompt() {
+        return 'probe';
+      },
+      async runConversation(_messages, _label, tools) {
+        return {
+          finalContent: 'probe complete',
+          usedTools: true,
+          changedFiles: [],
+          toolSummaries: [`allowed=${tools.map(tool => tool.name).join(',')}`],
+          executedTools: [{ tool: tools[0]?.name, success: true }],
+          usage: {},
+        };
+      },
+    };
+    const agent = new AgentTool(repl);
+    const run = await agent.run('probe real subagent behavior', { role: 'general', tools: ['Read'], processIsolation: false });
+    result.agentTool = run.success === true && run.status === 'completed' && run.usedTools === true && run.allowedTools?.includes('Read') && !run.allowedTools?.includes('Write');
+  } catch {
+    result.agentTool = false;
+  }
+
+  try {
+    const { EventEmitter } = await import('events');
+    const { AgentTool } = await import('../tools/agent.js');
+    const projectPath = await mkdtemp(path.join(tmpdir(), 'winter-scorecard-agent-'));
+    await writeFile(path.join(projectPath, 'README.md'), 'scorecard workspace', 'utf8');
+    const repl = {
+      constructor: { name: 'WinterREPL' },
+      projectPath,
+      sessionId: 'scorecard',
+      version: 'scorecard',
+      ai: {
+        getActiveProvider: () => 'probe',
+        setProvider: () => true,
+      },
+      tools: { getToolDefinitions: () => [] },
+      subagentFork: () => {
+        const child = new EventEmitter();
+        child.pid = 101;
+        child.stdout = new EventEmitter();
+        child.stderr = new EventEmitter();
+        child.kill = () => {};
+        child.send = message => {
+          queueMicrotask(() => child.emit('message', {
+            type: 'result',
+            result: {
+              success: true,
+              agentId: message.options.agentId,
+              summary: 'isolated',
+              workspaceIsolated: message.options.workspaceIsolation === true,
+              workspacePath: message.options.projectPath,
+            },
+          }));
+        };
+        return child;
+      },
+    };
+    const agent = new AgentTool(repl);
+    const run = await agent.run('probe process isolation', { processIsolation: true });
+    result.processIsolation = run.success === true && run.processIsolated === true && run.workspaceIsolated === true && run.childPid === 101;
+  } catch {
+    result.processIsolation = false;
+  }
+
+  try {
+    const { AgentRuntime } = await import('../agent/runtime.js');
+    let executed = false;
+    let turns = 0;
+    const repl = {
+      hydrateSessionToolPermissions() {},
+      isCancelled: false,
+      useUnicodeUi: false,
+      sessionPermissionGrants: new Set(),
+      session: { getContext: () => ({}), updateContext: async () => {} },
+      ai: { tools: [], _modelTier: 'medium', setTools() {} },
+      tools: {
+        normalizeToolName: name => String(name),
+        execute: async () => {
+          executed = true;
+          return { success: true };
+        },
+      },
+      selectExecutionProfile: () => ({ provider: 'probe', model: 'probe' }),
+      actionRequiresTools: () => false,
+      async requestAssistantTurn() {
+        turns += 1;
+        if (turns === 1) {
+          return { assistantMsg: { content: '' }, toolCalls: [{ id: 'x', toolName: 'Bash', toolArgs: { command: 'echo no' } }] };
+        }
+        return { assistantMsg: { content: 'done' }, toolCalls: [], finalContent: 'done' };
+      },
+      buildToolCallSignature: calls => JSON.stringify(calls.map(call => call.toolName)),
+      formatToolCallsForMessage: calls => calls,
+      buildPromptToolResultForModel: async (_tool, value) => value,
+      formatToolResultForConsole: (_tool, value) => value.error || '',
+      shouldPromptForToolPermission: async () => false,
+      recoverToolArgs: () => null,
+      enrichToolArgs: (_tool, args) => args,
+      buildToolFallbackAnswer: values => values.join('\n'),
+      getLatestUserText: messages => messages.at(-1)?.content || '',
+      shouldAutoVerifyAfterTools: () => false,
+    };
+    const runtime = new AgentRuntime(repl);
+    const run = await runtime.runConversation([{ role: 'user', content: 'probe' }], 'probe', [{ name: 'Read' }]);
+    result.scopedTools = executed === false && run.toolSummaries?.join('\n').includes('not allowed for this agent');
+  } catch {
+    result.scopedTools = false;
+  }
+
+  try {
+    const { WinterInputController } = await import('../cli/input-controller.js');
+    const repl = {
+      slashMenu: {
+        open: true,
+        line: '/',
+        items: Array.from({ length: 12 }, (_, index) => ({ cmd: `/cmd${index}`, desc: `Command ${index}` })),
+        selected: 0,
+        offset: 0,
+        printedLines: 0,
+      },
+      rl: { line: '/', prompt() {} },
+      getSlashSuggestions: () => [],
+    };
+    const input = new WinterInputController(repl);
+    input.renderSlashMenu = () => {};
+    for (let i = 0; i < 8; i++) input.moveSlashSelection(1);
+    result.slashMenu = repl.slashMenu.selected === 8 && repl.slashMenu.offset > 0;
+  } catch {
+    result.slashMenu = false;
+  }
+
+  return result;
+}
+
 export async function assessWinterCapabilities(repl = {}) {
   const projectPath = repl.projectPath || process.cwd();
   const srcPath = path.join(PACKAGE_ROOT, 'src');
   const resourceRoot = path.join(PACKAGE_ROOT, 'resources');
   const tools = repl.tools?.getToolDefinitions?.() || repl.getAgentTools?.('general') || [];
   const toolNames = new Set(tools.map(tool => tool.name || tool.function?.name).filter(Boolean));
+  const hasSourceText = (relativePath, pattern) => {
+    try {
+      return pattern.test(readFileSync(path.join(srcPath, relativePath), 'utf8'));
+    } catch {
+      return false;
+    }
+  };
 
+  const behavior = await runBehaviorProbes();
   const probes = {
     agentRuntime: Boolean(repl.agentRuntime) || existsSync(path.join(srcPath, 'agent', 'runtime.js')),
     toolEvidenceGuard: existsSync(path.join(srcPath, 'cli', 'repl.test.js')),
-    loopProtection: typeof repl.runConversation === 'function',
+    loopProtection: typeof repl.runConversation === 'function' || existsSync(path.join(srcPath, 'agent', 'runtime.js')),
 
     toolExecutor: Boolean(repl.tools) || existsSync(path.join(srcPath, 'tools', 'executor.js')),
-    toolDoctor: typeof repl.runToolDoctor === 'function',
+    toolDoctor: typeof repl.runToolDoctor === 'function' || existsSync(path.join(srcPath, 'cli', 'diagnostics.js')),
     fallbackParser: existsSync(path.join(srcPath, 'cli', 'tool-call-adapter.js')),
 
     codebaseIndex: typeof repl.ensureCodebaseIndex === 'function' || existsSync(path.join(srcPath, 'codebase-index', 'indexer.js')),
-    codebaseContext: typeof repl.buildCodebaseContext === 'function',
+    codebaseContext: typeof repl.buildCodebaseContext === 'function' || existsSync(path.join(srcPath, 'codebase-index', 'search.js')),
     atContext: existsSync(path.join(srcPath, 'cli', 'at-context.js')),
 
     tokenJuice: Boolean(repl.tokenJuice) || existsSync(path.join(srcPath, 'context', 'token-juice.js')),
@@ -164,20 +341,22 @@ export async function assessWinterCapabilities(repl = {}) {
     sessionCompression: typeof repl.compressSessionContext === 'function' || existsSync(path.join(srcPath, 'context', 'compress.js')),
 
     agentRegistry: Boolean(repl.agentRegistry) || existsSync(path.join(srcPath, 'agent', 'agent-definitions.js')),
-    agentTool: toolNames.has('Agent') || existsSync(path.join(srcPath, 'tools', 'agent.js')),
-    scopedTools: typeof repl.getAgentTools === 'function',
+    agentTool: behavior.agentTool,
+    scopedTools: behavior.scopedTools,
+    processIsolation: behavior.processIsolation,
 
     bottomInput: Boolean(repl.inputController) || existsSync(path.join(srcPath, 'cli', 'input-controller.js')),
-    directImagePaste: typeof repl.handleDirectClipboardPaste === 'function',
-    slashMenu: Array.isArray(repl.getSlashSuggestions?.('/')) || existsSync(path.join(srcPath, 'cli', 'slash-commands.js')),
+    directImagePaste: typeof repl.handleDirectClipboardPaste === 'function' || hasSourceText(path.join('cli', 'input-controller.js'), /handleDirectClipboardPaste|clipboardImage|imageAttachments/),
+    slashMenu: behavior.slashMenu && (Array.isArray(repl.getSlashSuggestions?.('/')) || existsSync(path.join(srcPath, 'cli', 'slash-commands.js'))),
 
     providerManager: Boolean(repl.ai) || existsSync(path.join(srcPath, 'ai', 'providers.js')),
-    providerSwitch: typeof repl.ai?.switchProvider === 'function',
+    providerSwitch: typeof repl.ai?.switchProvider === 'function' || hasSourceText(path.join('ai', 'providers.js'), /async\s+switchProvider|switchProvider\s*\(/),
     modelTier: existsSync(path.join(srcPath, 'ai', 'model-capabilities.js')),
 
-    autoDebug: typeof repl.runAutoHealing === 'function',
-    browserDebug: toolNames.has('BrowserDebug'),
-    verificationCommands: existsSync(path.join(srcPath, 'ai', 'prompts', 'success-criteria.js')),
+    autoDebug: typeof repl.runAutoHealing === 'function' || hasSourceText(path.join('cli', 'repl.js'), /runAutoHealing|verifyAndHeal/),
+    browserDebug: toolNames.has('BrowserDebug') || hasSourceText(path.join('tools', 'executor.js'), /BrowserDebug|OpenBrowser/),
+    browserSmoke: hasSourceText(path.join('..', 'scripts', 'smoke-browser.js'), /BrowserDebug[\s\S]*VisibleBrowser|VisibleBrowser[\s\S]*BrowserDebug/),
+    verificationCommands: typeof repl.inferVerificationCommands === 'function' || hasSourceText(path.join('cli', 'repl.js'), /inferVerificationCommands/),
 
     mcp: existsSync(path.join(srcPath, 'mcp', 'client.js')),
     resources: existsSync(path.join(resourceRoot, 'local', 'manifest.json')),

package/src/ai/hermes-core.js

@@ -0,0 +1,77 @@
+export const HERMES_CORE_RESOURCE = 'hermes-agent-core';
+
+export const HERMES_CORE_PATTERNS = [
+  {
+    key: 'self_improving_loop',
+    label: 'Closed learning loop',
+    rule: 'After non-trivial work, capture reusable procedures, failure modes, and verification evidence so future turns start smarter.',
+  },
+  {
+    key: 'skill_lifecycle',
+    label: 'Skill lifecycle',
+    rule: 'Promote repeated workflows into skills, improve skills when they fail, and keep skill instructions operational rather than decorative.',
+  },
+  {
+    key: 'session_search',
+    label: 'Session search and compression',
+    rule: 'Search or summarize prior context before broad guessing; compress long trajectories into high-signal facts and decisions.',
+  },
+  {
+    key: 'delegation',
+    label: 'Subagent delegation',
+    rule: 'Split independent workstreams into bounded subagents or parallel tool calls, then merge evidence before finalizing.',
+  },
+  {
+    key: 'automation_triggers',
+    label: 'Automation triggers',
+    rule: 'For recurring checks, scheduled work, webhook-like events, or background audits, design a trigger, context injection, verification, and delivery path.',
+  },
+  {
+    key: 'tui_gateway',
+    label: 'TUI gateway separation',
+    rule: 'Keep UI rendering, command registry, model loop, tools, and session state as separable surfaces with explicit events and status.',
+  },
+  {
+    key: 'tool_gateway',
+    label: 'Tool gateway discipline',
+    rule: 'Treat MCP/tools as a gateway with allowlists, diagnostics, retries, timeouts, and concrete tool-result evidence.',
+  },
+];
+
+export function detectHermesCoreSignals({ taskText = '', projectSignals = [] } = {}) {
+  const text = `${String(taskText || '')}\n${(projectSignals || []).join('\n')}`.toLowerCase();
+  const has = (...keywords) => keywords.some(keyword => text.includes(keyword));
+
+  return {
+    agent: has('agent', 'subagent', 'multi-agent', 'multi agent', 'ai assistant', 'coding assistant'),
+    skills: has('skill', 'skills', 'procedural memory', 'self-improv', 'self improv', 'learning loop'),
+    memory: has('memory', 'memories', 'session search', 'conversation history', 'compress context', 'trajectory'),
+    automation: has('cron', 'schedule', 'scheduled', 'webhook', 'routine', 'automation', 'background job'),
+    gateway: has('gateway', 'telegram', 'discord', 'slack', 'whatsapp', 'signal', 'messaging'),
+    tui: has('tui', 'terminal ui', 'ink', 'composer', 'slash command', 'autocomplete'),
+    mcp: has('mcp', 'tool gateway', 'toolset', 'tool registry', 'tool calling'),
+  };
+}
+
+export function shouldApplyHermesCore(input = {}) {
+  const signals = detectHermesCoreSignals(input);
+  return Object.values(signals).some(Boolean);
+}
+
+export function buildHermesCoreContract({ compact = false } = {}) {
+  const selected = compact
+    ? HERMES_CORE_PATTERNS.filter(pattern => ['self_improving_loop', 'skill_lifecycle', 'delegation', 'tool_gateway'].includes(pattern.key))
+    : HERMES_CORE_PATTERNS;
+
+  const lines = [
+    '## Hermes Core Agent Contract',
+    '- Apply Hermes-inspired core behavior directly inside Winter: self-improving skills, searchable memory, delegated workstreams, scheduled automation thinking, and tool-gateway discipline.',
+    ...selected.map(pattern => `- ${pattern.label}: ${pattern.rule}`),
+  ];
+
+  if (!compact) {
+    lines.push('- UI/TUI work: expose model state, tool progress, interrupts, command discovery, and evidence without fake progress text.');
+  }
+
+  return lines.join('\n');
+}

package/src/ai/model-capabilities.js

@@ -18,11 +18,51 @@ const TIER_ORDER = [MODEL_TIERS.TINY, MODEL_TIERS.SMALL, MODEL_TIERS.MEDIUM, MOD
 
 /**
  * Classify a model name into a capability tier.
- * Winter now treats every active model as flagship.
+ * Winter still pushes maximum reasoning for every model, but the real tier matters
+ * for prompt size, tool-result budgets, and small-model guardrails.
  * @returns {string} One of MODEL_TIERS
  */
 export function classifyModelTier(modelName, provider = '') {
-  return MODEL_TIERS.FLAGSHIP;
+  const raw = `${provider || ''} ${modelName || ''}`.toLowerCase();
+  if (!raw.trim()) return MODEL_TIERS.MEDIUM;
+
+  if (/\b(tiny|nano|0\.5b|1b|1\.5b|2b|2\.7b)\b/.test(raw)) {
+    return MODEL_TIERS.TINY;
+  }
+
+  const paramMatch = raw.match(/(?:^|[^0-9])(\d+(?:\.\d+)?)\s*b(?:[^a-z]|$)/);
+  if (paramMatch) {
+    const params = Number(paramMatch[1]);
+    if (Number.isFinite(params)) {
+      if (params < 3) return MODEL_TIERS.TINY;
+      if (params < 15) return MODEL_TIERS.SMALL;
+      if (params < 40) return MODEL_TIERS.MEDIUM;
+      if (params < 120) return MODEL_TIERS.LARGE;
+      return MODEL_TIERS.FLAGSHIP;
+    }
+  }
+
+  if (/\b(mini|small|lite|light|fast|flash|haiku|3b|7b|8b|9b|13b|14b)\b/.test(raw)) {
+    return MODEL_TIERS.SMALL;
+  }
+
+  if (/\b(sonnet|opus|gpt-5|gpt-4\.1|gpt-4o|o3|o4|gemini-2\.5-pro|minimax-m2|m2\.5|deepseek-r1|kimi-k2)\b/.test(raw)) {
+    return MODEL_TIERS.FLAGSHIP;
+  }
+
+  if (/\b(70b|72b|90b|large|pro|command-r|llama3\.1|llama-3\.1)\b/.test(raw)) {
+    return MODEL_TIERS.LARGE;
+  }
+
+  if (/\b(32b|34b|medium|codestral|qwen2\.5-coder)\b/.test(raw)) {
+    return MODEL_TIERS.MEDIUM;
+  }
+
+  if (/\b(ollama|lmstudio|local|llama|qwen|mistral|gemma|phi|yi-coder|deepseek-coder)\b/.test(raw)) {
+    return MODEL_TIERS.SMALL;
+  }
+
+  return MODEL_TIERS.MEDIUM;
 }
 
 /**

package/src/ai/prompts/system-prompt.js

@@ -5,7 +5,9 @@
  */
 
 import { formatRuntimeEnvironmentSummary, getRuntimeEnvironment } from '../../cli/runtime-env.js';
+import { buildHermesCoreContract } from '../hermes-core.js';
 import { getModelBudgetMultiplier } from '../model-capabilities.js';
+import { buildCodingMasteryContract, buildSmallModelAmplification } from '../small-model-amplifier.js';
 
 const BASE_PRINCIPLES = [
   'Execute, don\'t describe - Do the work, don\'t write plans about doing the work',
@@ -23,7 +25,7 @@ const TOOL_CATEGORIES = {
   shell: ['Bash', 'Glob', 'Grep'],
   task: ['TaskCreate', 'TaskUpdate', 'TaskList'],
   web: ['WebFetch', 'WebSearch', 'WebArchive'],
-  context: ['LSP', 'MCP', 'Parallel', 'Agent'],
+  context: ['LSP', 'MCP', 'Parallel', 'Agent', 'DelegateTask', 'ParallelAgent'],
   plan: ['TodoWrite', 'TodoList', 'ScheduleWakeup'],
   notebook: ['NotebookRead', 'NotebookEdit'],
 };
@@ -86,8 +88,13 @@ function appendSharedContext(parts, { environment, session, design, resourceCont
 }
 
 function buildStandardSystemPrompt(options = {}) {
-  const { role = 'coding', tools = [], resourceContext, modelTier = '' } = options;
+  const { role = 'coding', tools = [], resourceContext, modelTier = '', context } = options;
   const budgets = getPromptBudgets(modelTier);
+  const amplifier = buildSmallModelAmplification({
+    modelTier,
+    workflowProfile: role,
+    depth: context?.type || 'standard',
+  });
   const projectContextBudget = options.projectContextBudget ?? budgets.projectContextBudget;
   const compactSystemPrompt = options.compactSystemPrompt ?? budgets.compactSystemPrompt;
   const parts = [
@@ -100,10 +107,19 @@ function buildStandardSystemPrompt(options = {}) {
     'Use tools when they materially improve correctness. Inspect before editing. Verify after changes.',
     'Use maximum reasoning discipline for every model tier, including tiny, local, free, and routed models.',
     'Never invent file paths, APIs, command output, or test results.',
+    'For visible browser launch requests such as "mở chrome" or "open Chrome", use OpenBrowser; do not use Bash, Get-Command, Start-Process, or shell launch commands.',
     'For debug work, locate the first hard failure, patch the root cause, and verify with the closest test/build/browser smoke.',
+    'For live browser debugging and user-visible Chrome control, prefer MCP server chrome-devtools when configured; use its page, click, fill, snapshot, screenshot, console, network, and performance tools before falling back to headless browser automation.',
     'For design/UI work, inspect the existing interface and design resources first; avoid generic placeholder layouts.',
     'If the user attaches or pastes an image, analyze it as primary evidence.',
     '',
+    '## Winter Strength Amplifier',
+    amplifier.hint,
+    '',
+    buildCodingMasteryContract(),
+    '',
+    buildHermesCoreContract(),
+    '',
   ];
 
   const toolList = formatToolList(tools);

package/src/ai/small-model-amplifier.js

@@ -2,18 +2,46 @@ export function isWeakTier(modelTier = '') {
   return true;
 }
 
+export function buildCodingMasteryContract({ compact = false } = {}) {
+  const rules = [
+    'Read the code path before editing: entrypoint, caller, callee, config/env, and tests when they exist.',
+    'Identify invariants and side effects before changing behavior: data shape, async ordering, permissions, IO, cache, UI state, and provider differences.',
+    'Prefer the smallest correct patch, but update adjacent tests/docs/config when the contract changes.',
+    'After editing, review the diff mentally for syntax errors, dead code, race conditions, missing imports, wrong paths, and Windows path/shell issues.',
+    'Verify with the closest command. If verification is impossible, state the exact blocker and what evidence was still checked.',
+    'For mutating work, expect Winter to run verification before the final answer; use failures as the next debugging input instead of claiming success early.',
+    'Final answers must name concrete files changed and concrete verification results; no vague "should work" claims.',
+  ];
+
+  if (compact) {
+    return `## Coding Mastery Contract\n${rules.slice(0, 5).map(rule => `- ${rule}`).join('\n')}`;
+  }
+
+  return [
+    '## Coding Mastery Contract',
+    '- Act like a senior maintainer: understand the runtime path, preserve local patterns, and optimize for the user-visible failure.',
+    ...rules.map(rule => `- ${rule}`),
+    '- For reviews, lead with defects and risks. For implementation, finish with a short change summary and verification evidence.',
+  ].join('\n');
+}
+
 export function buildSmallModelAmplification({ modelTier = '', workflowProfile = 'general', depth = 'standard' } = {}) {
   const deepLike = depth === 'deep' || /debug|backend|data|devops|ai/.test(workflowProfile);
-  const maxToolTurns = deepLike ? 18 : 14;
+  const tier = String(modelTier || 'medium').toLowerCase();
+  const smallLike = /tiny|small/.test(tier);
+  const maxToolTurns = deepLike ? (smallLike ? 22 : 18) : (smallLike ? 18 : 14);
 
   const hint = [
     '[Winter Strength Amplifier]',
-    '- Every model, including tiny/local/free models, must run at Winter maximum capability.',
-    '- Mandatory internal loop: PLAN (requirements + files + risks) -> TOOL ACTIONS -> VERIFY -> PRIVATE SELF-CHECK -> FINAL.',
-    '- Do not skip verification. If verification fails, iterate until max loops.',
-    '- Before final answer, run a private self-critique silently; do not print the self-check or an improved-answer preface.',
-    '- Prefer concrete evidence from tool outputs over reasoning guesses.',
-    '- Use CodeGraph/codebase index context before broad file reads when available.',
+    `- Active model tier: ${tier}. Winter must compensate with stricter procedure, not weaker behavior.`,
+    '- Mandatory loop for action tasks: restate success criteria privately -> inspect real files/state -> make one concrete tool call -> read result -> continue -> verify -> final.',
+    '- If you are uncertain, call Read/Grep/Glob/Bash instead of guessing. Evidence beats reasoning guesses.',
+    '- For tool fallback mode, output exactly one tool call and no prose. Do not wrap tool calls in explanation.',
+    '- Do not claim files changed, browser checked, tests passed, or commands ran unless tool output in this turn proves it.',
+    '- Prefer small, high-signal context reads over broad dumps. Use CodeGraph/codebase index before broad file reads when available.',
+    '- Coding standard: follow the Coding Mastery Contract; inspect call sites and tests before edits, then verify the runtime path.',
+    '- After a failed tool or test, inspect the new failure and try the next smallest fix. Stop only at max tool turns or a real blocker.',
+    '- Before final answer, run a private self-check: requirement met, files touched, verification result, remaining risk. Do not print the self-check.',
   ].join('\n');
 
   return {

package/src/ai/workflow-selector.js

@@ -1,4 +1,5 @@
 import { classifyTask, TASK_CATEGORIES, TASK_TYPES } from './prompts/task-classifier.js';
+import { detectHermesCoreSignals, shouldApplyHermesCore } from './hermes-core.js';
 
 function hasAny(text, keywords) {
   return keywords.some(kw => text.includes(kw));
@@ -20,6 +21,7 @@ function detectTechnology(text, signals) {
     devops: hasAny(text, ['devops', 'ci/cd', 'docker', 'kubernetes', 'helm', 'terraform', 'ansible', 'deployment']) || hasSignal(/(docker|k8s|kubernetes|helm|terraform|github-actions|gitlab-ci)/),
     game: hasAny(text, ['game', 'unity', 'unreal', 'godot', 'multiplayer']) || hasSignal(/(unity|unreal|godot)/),
     ai: hasAny(text, ['ai agent', 'llm', 'rag', 'embedding', 'inference', 'model serving', 'mcp']) || hasSignal(/(langchain|llamaindex|embedding|transformer|onnx|mcp)/),
+    animation: hasAny(text, ['animation', 'animate', 'motion', 'transition', 'timeline', 'scrolltrigger', 'scroll trigger', 'scroll-driven', 'scroll animation', 'parallax', 'draggable', 'flip animation', 'splittext', 'morphsvg', 'greensock', 'gsap']) || hasSignal(/(gsap|greensock|scrolltrigger|framer-motion|motion|animation)/),
   };
 }
 
@@ -33,12 +35,14 @@ function buildTechnologySuggestions(tech) {
   if (tech.devops) suggestions.push('DevOps: Docker + CI/CD + IaC (Terraform), observability/logging');
   if (tech.game) suggestions.push('Game: Unity/Unreal/Godot, profiling, asset pipeline');
   if (tech.ai) suggestions.push('AI: RAG pipeline, vector DB, evals, prompt/version control');
+  if (tech.animation) suggestions.push('Animation: GSAP timelines, ScrollTrigger, framework cleanup, transform/opacity performance');
   return suggestions;
 }
 
 function buildVerificationStrategy(tech, taskInfo) {
   const checks = ['unit tests'];
   if (tech.web || tech.mobile || tech.desktop) checks.push('UI smoke tests');
+  if (tech.animation) checks.push('animation/browser smoke test');
   if (tech.backend) checks.push('API integration tests');
   if (tech.data) checks.push('data quality tests');
   if (tech.devops) checks.push('build + deploy dry-run checks');
@@ -53,6 +57,7 @@ export function selectWorkflow({ taskText = '', projectSignals = [], skillCatalo
 
   const taskInfo = classifyTask(text);
   const tech = detectTechnology(text, signals);
+  const hermesCore = detectHermesCoreSignals({ taskText, projectSignals });
 
   const recommendedSkills = [];
   const recommendedPlugins = [];
@@ -82,6 +87,14 @@ export function selectWorkflow({ taskText = '', projectSignals = [], skillCatalo
     recommendedSkills.push('vercel-react-best-practices');
   }
 
+  if (tech.animation) {
+    recommendedSkills.push('gsap', 'gsap-core', 'gsap-timeline', 'gsap-performance');
+    recommendedResources.push('gsap-skills');
+    if (tech.web) {
+      recommendedSkills.push('gsap-react', 'gsap-scrolltrigger');
+    }
+  }
+
   if (tech.mobile) {
     recommendedSkills.push('debug', 'test', 'performance', 'security');
   }
@@ -104,6 +117,14 @@ export function selectWorkflow({ taskText = '', projectSignals = [], skillCatalo
     recommendedResources.push('ecc');
   }
 
+  if (shouldApplyHermesCore({ taskText, projectSignals })) {
+    recommendedResources.push('hermes-agent-core');
+    recommendedSkills.push('hermes-agent', 'subagent-driven-development', 'systematic-debugging');
+    if (hermesCore.skills) recommendedSkills.push('hermes-agent-skill-authoring');
+    if (hermesCore.mcp) recommendedSkills.push('native-mcp');
+    if (hermesCore.automation) recommendedSkills.push('plan', 'test-driven-development');
+  }
+
   // When user mentions browser automation or interacting with websites, point at page-agent
   if (hasAny(text, ['browser', 'automation', 'crawl', 'scrape', 'form fill', 'e2e', 'playwright', 'selenium', 'page agent'])) {
     recommendedResources.push('page-agent');
@@ -143,6 +164,7 @@ export function selectWorkflow({ taskText = '', projectSignals = [], skillCatalo
     profile,
     depth,
     detectedTechnologies: tech,
+    hermesCore,
     technologySuggestions: buildTechnologySuggestions(tech),
     verificationStrategy: buildVerificationStrategy(tech, taskInfo),
     recommendedSkills: filteredSkills,
@@ -151,4 +173,3 @@ export function selectWorkflow({ taskText = '', projectSignals = [], skillCatalo
     recommendedResources: uniq(recommendedResources),
   };
 }
-

package/src/cli/commands.js

@@ -10,6 +10,7 @@ import { DesignCommands } from '../design/commands.js';
 import { SkillManager } from '../skills/manager.js';
 import { PluginManager } from '../plugins/manager.js';
 import { MCPClient } from '../mcp/client.js';
+import { getMcpPreset, upsertMcpServer } from '../mcp/presets.js';
 import { BenchmarkRunner } from '../ai/benchmark.js';
 import { redactSecrets } from './secret-env.js';
 import { formatRuntimeEnvironmentSummary, getRuntimeEnvironment } from './runtime-env.js';
@@ -813,6 +814,29 @@ EXECUTION CONTRACT:
         console.log(`${colors.green}✓ Added MCP server: ${name}${colors.reset}`);
         break;
       }
+      case 'preset':
+      case 'install': {
+        const [presetName, ...presetOptions] = rest;
+        if (!presetName) {
+          console.log(`${colors.yellow}Usage: winter mcp preset <chrome-devtools> [--isolated] [--headless] [--browser-url <url>]${colors.reset}`);
+          break;
+        }
+
+        try {
+          const server = getMcpPreset(presetName, presetOptions);
+          upsertMcpServer(config, server);
+          await this.config.save(config);
+          console.log(`${colors.green}OK Installed MCP preset: ${server.name}${colors.reset}`);
+          console.log(`  ${colors.dim}${server.command} ${server.args.join(' ')}${colors.reset}`);
+          if (!server.args.includes('--headless')) {
+            console.log(`  ${colors.dim}Visible Chrome mode: enabled. Use --headless only for background browser runs.${colors.reset}`);
+          }
+          console.log(`  ${colors.dim}Inspect tools with: winter mcp tools ${server.name}${colors.reset}`);
+        } catch (error) {
+          console.log(`${colors.red}${error.message}${colors.reset}`);
+        }
+        break;
+      }
       case 'remove': {
         const name = rest[0];
         if (!name) {
@@ -868,7 +892,7 @@ EXECUTION CONTRACT:
         break;
       }
       default:
-        console.log(`${colors.yellow}Usage: winter mcp <list|add|remove|allow|tools>${colors.reset}`);
+        console.log(`${colors.yellow}Usage: winter mcp <list|add|preset|install|remove|allow|tools>${colors.reset}`);
     }
   }
 
@@ -882,6 +906,9 @@ EXECUTION CONTRACT:
       case undefined:
       case 'list':
         console.log(`\n${colors.cyan}Permission Allowlist:${colors.reset}`);
+        console.log(`  Full access: ${config.sandbox?.enabled === false ? 'on' : 'off'}`);
+        console.log(`  Sandbox enabled: ${config.sandbox?.enabled !== false}`);
+        console.log(`  Restrict workspace: ${config.sandbox?.restrictToWorkspace !== false}`);
         console.log(`  Tools: ${(config.permissions.allowlist.tools || []).join(', ') || 'none'}`);
         console.log(`  Commands: ${(config.permissions.allowlist.commands || []).join(', ') || 'none'}`);
         console.log(`  MCP Servers: ${(config.permissions.allowlist.mcpServers || []).join(', ') || 'none'}`);
@@ -910,8 +937,25 @@ EXECUTION CONTRACT:
         console.log(`${colors.green}✓ promptByDefault = ${config.permissions.promptByDefault}${colors.reset}`);
         break;
       }
+      case 'full': {
+        const value = String(rest[0] || 'on').toLowerCase();
+        const enabled = !(value === 'off' || value === 'false' || value === '0' || value === 'no');
+        if (typeof this.config.setFullAccess === 'function') {
+          await this.config.setFullAccess(enabled);
+        } else {
+          config.sandbox = {
+            ...(config.sandbox || {}),
+            enabled: !enabled,
+            restrictToWorkspace: !enabled,
+          };
+          config.permissions.promptByDefault = !enabled;
+          await this.config.save(config);
+        }
+        console.log(`${colors.green}Full access ${enabled ? 'enabled' : 'disabled'}${colors.reset}`);
+        break;
+      }
       default:
-        console.log(`${colors.yellow}Usage: winter permissions <list|allow|prompt>${colors.reset}`);
+        console.log(`${colors.yellow}Usage: winter permissions <list|allow|prompt|full>${colors.reset}`);
     }
   }