winter-super-cli 2026.6.26 → 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 = [
@@ -106,6 +113,13 @@ function buildStandardSystemPrompt(options = {}) {
     '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

@@ -906,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'}`);
@@ -934,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}`);
     }
   }