@ryuenn3123/agentic-senior-core 3.0.23 → 3.0.26

package/.agent-context/prompts/bootstrap-design.md

@@ -27,17 +27,21 @@ The agent must summarize what it used from that research, discard what does not
 
 User-supplied research may influence the candidate set for motion, scroll, UI primitives, canvas/3D, charts, icons, typography, and interaction patterns, but the final choice must still be project-fit, accessible, performant, and maintainable.
 
-## Advanced Conceptual Anchor
+## Dynamic Avant-Garde Anchor Engine
 
-If the user requests UI work but provides no external research, design reference, screenshot study, or library note, do not start coding immediately. First synthesize one advanced conceptual anchor that will unify the interface.
+If the user requests UI work but provides no user-supplied research, design reference, screenshot study, or library note, do not start coding immediately. This is not permission to fall back to the scaffold, prior UI, or generic software metaphors. First synthesize one advanced conceptual anchor that will unify the interface.
 
-Do not use basic software UI labels as the final anchor, including "dashboard", "portal", "cards", "admin panel", "SaaS shell", or "minimalist interface".
+User-supplied research means current-task evidence from the user. The scaffold seed, this repo's offline examples, old design docs, and prior UI do not count as research. If live research is available, perform agent-led research into current official docs for any technology choices and current premium interaction/design patterns before selecting the anchor. If live research is unavailable, state that limitation in the design docs and synthesize from product context plus broad design knowledge without pretending the seed was research.
 
-The agent must consider at least three substantially different candidate anchors internally, discard predictable or generic candidates, and record only the surviving anchor and concise rationale. Do not expose hidden deliberation or the rejected candidate list.
+Do not use basic software UI labels as the final anchor, including "dashboard", "portal", "cards", "admin panel", "SaaS shell", "web app shell", or "minimalist interface".
 
-The final anchor must come from broad non-template domains such as complex physical engineering, high-end industrial design, experimental editorial structure, advanced architecture, scientific instrumentation, or spatial information systems. These are search domains, not style presets.
+The agent must internally consider at least three substantially different, high-variance candidate anchors, discard the two most obvious, safest, or easiest-to-predict options, and record only the surviving anchor and concise rationale. Do not expose hidden deliberation or the rejected candidate list.
 
-Write the chosen anchor into `docs/design-intent.json` as `conceptualAnchor`, then derive typography, spacing, density, color behavior, morphology, motion, and responsive composition from that single anchor. If a later design choice does not logically follow from the anchor, revise the contract before coding.
+The final anchor must come from broad non-template domains such as complex physical engineering, high-end industrial design, cinematic spatial interfaces, experimental editorial structure, advanced architecture, scientific instrumentation, advanced data visualization, exhibition/wayfinding systems, or premium interactive web experiences. These are search domains, not style presets.
+
+Write the chosen anchor into `docs/design-intent.json` as `conceptualAnchor`, including agentResearchMode, sourceDomain, rationale, derivedTokenLogic, visualRiskBudget, motionRiskBudget, and cohesionChecks. Typography, spacing, density, color behavior, morphology, motion, and responsive composition must logically derive from that single anchor. If a later design choice does not follow from the anchor, revise the contract before coding.
+
+Motion is not a garnish. Default to a rich motion plan: fluid transitions, spatial reveals, scroll choreography, micro-interactions, and modern motion libraries are expected when they strengthen the anchor and product experience. Keep reduced-motion fallbacks instead of suppressing motion, and solve performance deliberately instead of using safety language as a reason to stay static.
 
 ## Zero-Based Redesign Protocol
 
@@ -58,7 +62,7 @@ The UI must feel authored by a strong UI/UX designer, not assembled from default
 Do:
 - Synthesize a visual direction from the project context and explain why it fits.
 - Choose color, typography, spacing, motion, density, and component morphology dynamically from the product and audience.
-- Use modern, expressive interaction when it improves hierarchy, feedback, delight, confidence, or memorability.
+- Use modern, expressive interaction and motion as part of the core design language, especially when it improves hierarchy, feedback, delight, confidence, or memorability.
 - Keep frontend code clean, componentized, accessible, and easy to maintain.
 - Use tokens and semantic aliases so future changes do not require rewriting components.
 - Make design decisions explicit before coding, then implement consistently.

package/.agent-context/review-checklists/pr-checklist.md

@@ -65,7 +65,7 @@ Run this before declaring a task done. Apply only the sections relevant to the c
 - [ ] Visual direction is project-specific and not a template/default component-kit habit.
 - [ ] Responsive behavior recomposes content and priority, not only shrinking desktop layout.
 - [ ] Accessibility hard requirements are preserved: keyboard access, focus visibility, contrast, target size, status feedback, and no color-only meaning.
-- [ ] Motion is purposeful, reduced-motion-safe, and justified by product value.
+- [ ] Motion is treated as part of the design language for modern UI work, with reduced-motion and performance safeguards instead of defaulting to static screens.
 
 ## 8. Dependencies And Runtime
 

package/.agent-context/rules/frontend-architecture.md

@@ -52,6 +52,14 @@ Do not use this file to teach generic frontend basics the model already knows.
 - Do not let heading, body, and data/meta roles collapse into one safe typographic family without explicit rationale.
 - At least one visual, interaction, content, motion, or state behavior must read as project-specific at a glance.
 
+## Dynamic Avant-Garde Anchor Boundary
+
+- If the user gives no current-task visual research or reference, the scaffold, old UI, and existing design docs do not count as research.
+- Before UI code, choose one agent-synthesized conceptual anchor from high-variance non-software domains and record only the final anchor in `docs/design-intent.json`.
+- Internally reject the safest dashboard, portal, card-grid, admin-shell, or minimalist-web-app mental model before writing CSS.
+- Typography, spacing, morphology, motion, and responsive recomposition must derive from the chosen anchor, not from framework defaults.
+- Default to an expressive motion plan derived from the anchor. Use spatial transitions, micro-interactions, scroll choreography, and modern animation libraries when they improve the experience; include reduced-motion and performance safeguards without using them as an excuse for a static UI.
+
 ## Responsive Mutation Requirements
 
 - Responsive quality is not allowed to be scale-only. At least one surface must materially change position, grouping, priority, or disclosure strategy between mobile and desktop.
@@ -64,7 +72,7 @@ Do not use this file to teach generic frontend basics the model already knows.
 - Define the primary user task or reading path from current evidence before arranging surfaces.
 - Supporting surfaces must earn their placement through role, priority, or behavior. They must not feel like cloned modules.
 - Component states must preserve identity under hover, focus, loading, success, empty, and error. Do not let everything collapse into anonymous rounded panels.
-- Motion may be expressive, but it must strengthen hierarchy, feedback, or memorability while staying reduced-motion-safe and performant.
+- Motion should be expressive by default for modern UI work. Make it strengthen hierarchy, feedback, or memorability, then keep it reduced-motion-safe and performant.
 
 ## Implementation Boundaries
 

package/.agent-context/state/memory-continuity-benchmark.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-04-24T15:04:58.174Z",
+  "generatedAt": "2026-04-25T03:25:49.150Z",
   "reportName": "memory-continuity-benchmark",
   "schemaVersion": "1.0.0",
   "passed": true,

package/.cursorrules

@@ -1,6 +1,6 @@
 # AGENTIC-SENIOR-CORE DYNAMIC GOVERNANCE RULESET
 
-Generated by Agentic-Senior-Core CLI v3.0.23
+Generated by Agentic-Senior-Core CLI v3.0.26
 Timestamp: 2026-04-24T06:02:48.303Z
 Selected policy file: .agent-context/policies/llm-judge-threshold.json
 

package/.windsurfrules

@@ -1,6 +1,6 @@
 # AGENTIC-SENIOR-CORE DYNAMIC GOVERNANCE RULESET
 
-Generated by Agentic-Senior-Core CLI v3.0.23
+Generated by Agentic-Senior-Core CLI v3.0.26
 Timestamp: 2026-04-24T06:02:48.303Z
 Selected policy file: .agent-context/policies/llm-judge-threshold.json
 

package/README.md

@@ -10,12 +10,14 @@
 **Production-grade Rules Engine (Governance Engine) for AI coding agents.**
 Works with Cursor, Windsurf, GitHub Copilot, Claude Code, Gemini, and other LLM-powered IDE workflows.
 
-Latest release: 3.0.9 (2026-04-20).
+Latest release: 3.0.26 (2026-04-25).
 
-Highlights in 3.0.9:
-- Design bootstrap prompts now rely on shipped project evidence instead of assuming extra docs exist in every initialized repository.
-- Dynamic UI design guidance now emphasizes structure, rationale, and anti-generic constraints without anchoring to brand systems.
-- Init prompts now point agents at the active onboarding and compiled-rule context that actually exists in target projects.
+Highlights in 3.0.26:
+- Memory continuity now seeds `.agent-context/state/active-memory.json` once, so new sessions have a compact project-focus snapshot without overwriting active work during upgrade.
+- Token optimization now exposes an output folding strategy that preserves failures, file/line details, and actionable warnings while folding repetitive shell noise.
+- UI design guidance now treats expressive motion as a first-class default for modern interfaces instead of letting safety wording become an excuse for static screens.
+- Agents must use live/current-year research for ecosystem, framework, dependency, Docker, and modern UI/library claims instead of offline repository guesses.
+- Frontend guidance rejects safe dashboard/admin-panel defaults and requires responsive recomposition.
 
 </div>
 
@@ -37,6 +39,20 @@ One command to initialize rules, checklists, and strict AI coding guidelines con
 
 ---
 
+## Design Direction
+
+For UI, UX, layout, screen, Tailwind, frontend, or redesign work, the pack routes agents through the design bootstrap and frontend architecture rules before code changes.
+
+The intended behavior is agent-led, not offline-template-led:
+
+- Existing projects: read the real repository, docs, UI surface, and current user brief before changing design.
+- Fresh projects: ask the LLM agent to recommend the stack and design approach from current evidence instead of silently choosing a hardcoded framework.
+- No visual reference provided: synthesize one modern conceptual anchor first, then derive typography, spacing, morphology, motion, and responsive behavior from that anchor.
+- Modern UI claims: research current-year libraries and patterns when relevant; 2026 work should use 2026 evidence, and future years should update automatically through agent research.
+- Anti-generic rule: avoid safe dashboard shells, admin panels, card grids, scale-only mobile layouts, and static no-motion interfaces unless the product context explicitly justifies them.
+
+---
+
 ## MCP Quick Setup (VS Code)
 
 1. Generate workspace MCP config:

package/lib/cli/commands/init.mjs

@@ -67,6 +67,7 @@ import {
 } from '../token-optimization.mjs';
 import {
   createMemoryContinuityState,
+  ensureActiveMemorySnapshot,
   writeMemoryContinuityState,
 } from '../memory-continuity.mjs';
 
@@ -603,6 +604,9 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
       });
 
       await writeMemoryContinuityState(resolvedTargetDirectoryPath, memoryContinuityState);
+      await ensureActiveMemorySnapshot(resolvedTargetDirectoryPath, {
+        projectName: path.basename(resolvedTargetDirectoryPath),
+      });
       console.log(`Project memory continuity metadata enabled (${memoryContinuityState.hydrationMode}, host-supported).`);
     }
 
@@ -748,6 +752,7 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
         hydrationMode: memoryContinuityState?.hydrationMode || null,
         adapters: memoryContinuityState?.adapters || [],
         stateFile: isMemoryContinuityEnabled ? '.agent-context/state/memory-continuity.json' : null,
+        activeSnapshotFile: isMemoryContinuityEnabled ? '.agent-context/state/active-memory.json' : null,
       },
       detectionTransparency,
       uiScopeSignals: existingProjectUiScopeSignals,

package/lib/cli/commands/upgrade.mjs

@@ -47,6 +47,7 @@ import {
   detectProjectDocTemplateStaleness,
   buildDesignIntentSeedFromSignals,
 } from '../project-scaffolder.mjs';
+import { ensureActiveMemorySnapshot } from '../memory-continuity.mjs';
 
 export function parseUpgradeArguments(commandArguments) {
   const parsedUpgradeOptions = {
@@ -401,6 +402,7 @@ export async function runUpgradeCommand(targetDirectoryArgument, upgradeOptions
         managedSurfacePlan,
       });
       const supplementalCreatedFileNames = [];
+      const shouldEnsureActiveMemorySnapshot = existingOnboardingReport?.memoryContinuity?.enabled !== false;
 
       if (shouldSeedDesignIntentOnApply && designIntentSeedContent) {
         const docsDirectoryPath = path.join(resolvedTargetDirectoryPath, 'docs');
@@ -410,6 +412,16 @@ export async function runUpgradeCommand(targetDirectoryArgument, upgradeOptions
         supplementalCreatedFileNames.push('docs/design-intent.json');
       }
 
+      if (shouldEnsureActiveMemorySnapshot) {
+        const activeMemoryResult = await ensureActiveMemorySnapshot(resolvedTargetDirectoryPath, {
+          projectName: packageManifest?.name || path.basename(resolvedTargetDirectoryPath),
+        });
+
+        if (activeMemoryResult.created) {
+          supplementalCreatedFileNames.push('.agent-context/state/active-memory.json');
+        }
+      }
+
       await compileDynamicContext({
         targetDirectoryPath: resolvedTargetDirectoryPath,
         selectedStackFileName,

package/lib/cli/memory-continuity.mjs

@@ -36,8 +36,10 @@ const INLINE_SENSITIVE_PATTERNS = [
 
 export const MEMORY_SCHEMA_VERSION = '1.0.0';
 export const MEMORY_CONTINUITY_STATE_FILE_NAME = 'memory-continuity.json';
+export const ACTIVE_MEMORY_STATE_FILE_NAME = 'active-memory.json';
 
 const MEMORY_CONTINUITY_STATE_SCHEMA_VERSION = 'memory-continuity-v1';
+const ACTIVE_MEMORY_STATE_SCHEMA_VERSION = 'active-memory-v1';
 
 export const SUPPORTED_MEMORY_ADAPTER_IDS = Object.freeze([
   'claude-code',
@@ -359,6 +361,138 @@ export async function writeMemoryContinuityState(targetDirectoryPath, memoryCont
   await fs.writeFile(stateFilePath, JSON.stringify(memoryContinuityState, null, 2) + '\n', 'utf8');
 }
 
+export function createActiveMemorySnapshot(options = {}) {
+  return {
+    schemaVersion: ACTIVE_MEMORY_STATE_SCHEMA_VERSION,
+    snapshotPurpose: 'compact-cross-session-continuity',
+    updatePolicy: {
+      writeWhen: 'natural-task-boundary',
+      overwriteOnlyWithCurrentRepoEvidence: true,
+      preserveUserOwnedContent: true,
+    },
+    project: {
+      name: toNonEmptyString(options.projectName, ''),
+      currentFocus: '',
+      durableFacts: [],
+    },
+    progress: {
+      lastAchievements: [],
+      pendingIssues: [],
+      nextBestActions: [],
+      validationState: [],
+    },
+    designContinuity: {
+      visualLanguageContinuity: 'opt-in-only',
+      currentConceptualAnchor: '',
+      forbiddenCarryover: [
+        'prior-project-style-memory',
+        'old-ui-visual-dna-without-user-approval',
+        'generic-dashboard-defaults',
+      ],
+    },
+    privacy: {
+      storeSecrets: false,
+      storeRawChatLogs: false,
+      redactSensitiveTextBeforeWriting: true,
+    },
+    generatedAt: new Date().toISOString(),
+    lastUpdatedAt: null,
+  };
+}
+
+export function validateActiveMemorySnapshot(activeMemorySnapshot) {
+  const validationErrors = [];
+
+  if (!activeMemorySnapshot || typeof activeMemorySnapshot !== 'object') {
+    return ['active-memory snapshot must be an object.'];
+  }
+
+  if (activeMemorySnapshot.schemaVersion !== ACTIVE_MEMORY_STATE_SCHEMA_VERSION) {
+    validationErrors.push(`active-memory.schemaVersion must equal "${ACTIVE_MEMORY_STATE_SCHEMA_VERSION}".`);
+  }
+
+  if (activeMemorySnapshot.snapshotPurpose !== 'compact-cross-session-continuity') {
+    validationErrors.push('active-memory.snapshotPurpose must equal "compact-cross-session-continuity".');
+  }
+
+  const serializedSnapshot = JSON.stringify(activeMemorySnapshot);
+  if (estimateTokenUsage(serializedSnapshot) > 3000) {
+    validationErrors.push('active-memory snapshot must stay compact enough for session-start hydration.');
+  }
+
+  const redactionProbe = redactSensitiveMemoryText(serializedSnapshot);
+  if (redactionProbe.wasRedacted) {
+    validationErrors.push('active-memory snapshot must not contain secret-like fields, bearer tokens, or private blocks.');
+  }
+
+  if (activeMemorySnapshot.privacy?.storeSecrets !== false) {
+    validationErrors.push('active-memory.privacy.storeSecrets must equal false.');
+  }
+
+  if (activeMemorySnapshot.privacy?.storeRawChatLogs !== false) {
+    validationErrors.push('active-memory.privacy.storeRawChatLogs must equal false.');
+  }
+
+  if (activeMemorySnapshot.privacy?.redactSensitiveTextBeforeWriting !== true) {
+    validationErrors.push('active-memory.privacy.redactSensitiveTextBeforeWriting must equal true.');
+  }
+
+  for (const arrayPath of [
+    ['project', 'durableFacts'],
+    ['progress', 'lastAchievements'],
+    ['progress', 'pendingIssues'],
+    ['progress', 'nextBestActions'],
+    ['progress', 'validationState'],
+  ]) {
+    const arrayValue = arrayPath.reduce((currentValue, pathSegment) => currentValue?.[pathSegment], activeMemorySnapshot);
+    const pathLabel = `active-memory.${arrayPath.join('.')}`;
+    if (!Array.isArray(arrayValue)) {
+      validationErrors.push(`${pathLabel} must be an array.`);
+      continue;
+    }
+
+    if (arrayValue.length > 12) {
+      validationErrors.push(`${pathLabel} must stay compact and contain at most 12 entries.`);
+    }
+  }
+
+  if (activeMemorySnapshot.designContinuity?.visualLanguageContinuity !== 'opt-in-only') {
+    validationErrors.push('active-memory.designContinuity.visualLanguageContinuity must equal "opt-in-only".');
+  }
+
+  return validationErrors;
+}
+
+export async function ensureActiveMemorySnapshot(targetDirectoryPath, options = {}) {
+  const stateDirectoryPath = path.join(targetDirectoryPath, '.agent-context', 'state');
+  const stateFilePath = path.join(stateDirectoryPath, ACTIVE_MEMORY_STATE_FILE_NAME);
+
+  if (await pathExists(stateFilePath)) {
+    return {
+      created: false,
+      filePath: stateFilePath,
+    };
+  }
+
+  await fs.mkdir(stateDirectoryPath, { recursive: true });
+  const activeMemorySnapshot = createActiveMemorySnapshot(options);
+  const validationErrors = validateActiveMemorySnapshot(activeMemorySnapshot);
+  if (validationErrors.length > 0) {
+    throw new Error(`Invalid active memory snapshot seed: ${validationErrors.join(' ')}`);
+  }
+
+  await fs.writeFile(
+    stateFilePath,
+    JSON.stringify(activeMemorySnapshot, null, 2) + '\n',
+    'utf8'
+  );
+
+  return {
+    created: true,
+    filePath: stateFilePath,
+  };
+}
+
 export function buildMemoryContinuityGuidanceBlock(memoryContinuityState) {
   if (!memoryContinuityState?.enabled) {
     return [
@@ -384,9 +518,12 @@ export function buildMemoryContinuityGuidanceBlock(memoryContinuityState) {
     adapterGuidanceLine,
     '',
     'Session-start retrieval policy:',
+    '- Read `.agent-context/state/active-memory.json` first when it exists; it is the compact project-focus snapshot.',
     `- Load compact index first (limit: ${sessionStartIndexLimit} entries).`,
     `- Hydrate full detail only for highest-value entries (limit: ${fullHydrationLimit}).`,
     '- Always redact sensitive text before persistence (<private> blocks and inline secret-like fields).',
+    '- Refresh `active-memory.json` at natural task boundaries, but never store secrets, raw chat logs, or stale visual taste.',
+    '- Current repo evidence, current user brief, and live research override active-memory when they conflict.',
     '',
     'Host compatibility scope:',
     '- This memory layer does not replace reading bootstrap instruction files at the start of a session.',

package/lib/cli/project-scaffolder/design-contract.mjs

@@ -51,8 +51,6 @@ function buildStructureFirstSeedSignals({
 
   return {
     designPhilosophy: `Use ${evidenceSourceLabel} to synthesize the design system for ${projectName || 'this project'}. This seed is only a decision scaffold: the LLM must choose the visual language, libraries, color system, typography, spacing, and interaction model from ${projectContextLabel}, current repo evidence, and live official documentation when a technology claim is needed.`,
-    brandAdjectives: ['agent-synthesized-from-current-context'],
-    antiAdjectives: ['offline-prescribed-style', 'template-by-default', 'scale-only-responsive', 'unresearched-library-choice'],
     typographyScaleRatio: 'agent-calibrated-from-content-platform-and-readability',
     baseGridUnit: 'agent-calibrated-from-platform-density-and-implementation-stack',
     spacingPattern: 'agent-defined-from-task-flow-and-viewport-needs',
@@ -60,16 +58,9 @@ function buildStructureFirstSeedSignals({
     colorIntent: `Choose semantic palette roles from ${projectContextLabel}, current repo evidence, and accessibility needs. Do not inherit fixed palettes or generic SaaS color defaults from this scaffold.`,
     paletteRoles: ['agent-defined-semantic-roles'],
     distinctiveMoves: [
-      'Research and choose a current, project-fit visual direction instead of inheriting any offline preset from this scaffold.',
-      'Define at least one recognizable design move from the product task, audience, content, and repo evidence before implementation.',
-      'Document why the chosen move belongs to this project and which common LLM bad habit it intentionally avoids.',
+      'Choose one recognizable design move from product task, audience, content, repo evidence, and current docs; do not inherit a scaffold preset.',
     ],
-    motionPurpose: 'Use modern motion when it improves hierarchy, continuity, feedback, memorability, or perceived product quality. If implementation needs a motion library, the LLM must choose a current compatible option from official docs instead of relying on an offline default.',
-    motionChoreography: 'Define choreography from the product experience and implementation stack. Keep it performant and reduced-motion-safe; do not suppress rich interaction by default.',
-    motionDurations: {
-      desktop: 'agent-calibrated',
-      mobile: 'agent-calibrated',
-    },
+    motionPurpose: 'Default to a modern motion plan for UI work: use expressive transitions, spatial choreography, micro-interactions, and motion libraries when they strengthen hierarchy, continuity, feedback, memorability, or perceived product quality. If implementation needs a motion library, the LLM must choose a current compatible option from official docs instead of relying on an offline default.',
     componentMorphology: {
       mobile: 'Recompose the experience for touch, task priority, and constrained attention. Mobile should be a deliberate mobile design, not a shrunken desktop.',
       tablet: 'Regroup surfaces for medium-width use, preserving task clarity without cloning either desktop or mobile blindly.',
@@ -121,8 +112,6 @@ function buildDesignIntentContractObject({
         : toTitleCase(initContext.blueprintFileName),
     },
     designPhilosophy: inferredKeywords.designPhilosophy,
-    brandAdjectives: inferredKeywords.brandAdjectives,
-    antiAdjectives: inferredKeywords.antiAdjectives,
     visualDirection: {
       seedMode: 'scaffold-only',
       requiresProjectSpecificSynthesis: true,
@@ -139,11 +128,8 @@ function buildDesignIntentContractObject({
       candidateDomains: [
         'visual-direction',
         'motion-and-scroll',
-        'ui-primitives',
-        'canvas-3d-or-rich-media',
-        'charts-and-data-visualization',
-        'icons-and-illustration',
-        'typography-and-interaction-patterns',
+        'ui-primitives-or-rich-media',
+        'typography-and-interaction',
       ],
       finalDecisionAuthority: 'agent-llm-from-project-fit-accessibility-performance-maintainability-and-current-official-docs',
     },
@@ -151,33 +137,44 @@ function buildDesignIntentContractObject({
       mode: 'required-when-no-external-research',
       seedMode: 'selection-policy-only',
       requiresAgentSelectionBeforeUiImplementation: true,
+      userResearchAbsencePolicy: {
+        userSuppliedResearchOnly: true,
+        scaffoldSeedDoesNotCountAsResearch: true,
+        priorUiDoesNotCountAsResearch: true,
+        requireAgentLedResearchWhenAvailable: true,
+      },
       candidateSelectionPolicy: {
         considerAtLeast: 3,
+        discardObviousCandidateCount: 2,
+        minimumCandidateDistance: 'high',
         discardPredictableCandidates: true,
+        preferDistinctiveOverSafe: true,
         doNotRevealHiddenCandidateList: true,
         outputOnlyChosenAnchor: true,
       },
       forbiddenFinalAnchorTerms: [
         'dashboard',
-        'portal',
         'cards',
         'admin-panel',
         'saas-shell',
         'minimalist-interface',
+        'safe-admin-layout',
       ],
       sourceDomains: [
         'complex-physical-engineering',
-        'high-end-industrial-design',
+        'cinematic-spatial-interface',
         'experimental-editorial-structure',
-        'advanced-architecture',
         'scientific-instrumentation',
-        'spatial-information-systems',
+        'premium-interactive-web-experiences',
       ],
+      visualRiskBudget: {
+        mode: 'high-distinctiveness-with-accessibility-and-performance-guardrails',
+        allowRichMotionAndMicroInteraction: true,
+        rejectTimidDefaultWhenAnchorSupportsExpressiveUi: true,
+        requireReducedMotionFallback: true,
+      },
       requiredDerivedAxes: [
         'typography',
-        'spacing',
-        'density',
-        'color-behavior',
         'morphology',
         'motion',
         'responsive-composition',
@@ -185,19 +182,21 @@ function buildDesignIntentContractObject({
       finalAnchorContract: {
         requiredFields: [
           'name',
+          'agentResearchMode',
           'sourceDomain',
           'rationale',
           'derivedTokenLogic',
+          'visualRiskBudget',
+          'motionRiskBudget',
           'cohesionChecks',
         ],
         derivedTokenLogicAxes: [
-          'typography',
-          'spacing',
-          'density',
-          'color-behavior',
           'morphology',
           'motion',
-          'responsive-composition',
+        ],
+        cohesionChecks: [
+          'no-dashboard-mental-model',
+          'motion-derived-from-anchor',
         ],
       },
     },
@@ -217,7 +216,6 @@ function buildDesignIntentContractObject({
       componentTokensConsumeSemantic: true,
       forbidDirectComponentPrimitiveBypass: true,
       aliasReferenceStyle: 'brace-reference',
-      aliasingStrategy: 'Primitive tokens hold raw values, semantic tokens carry intent, and component tokens consume semantic aliases instead of raw values.',
       fallbackPolicy: {
         forbidRawHexOutsidePrimitives: true,
         forbidRawSpacingOutsidePrimitives: true,
@@ -228,12 +226,6 @@ function buildDesignIntentContractObject({
         forbidDotsInNames: true,
         forbidSquareBracketsInNames: true,
       },
-      tokenLayerRoles: {
-        primitive: 'Raw values such as colors, spacing, radius, typography, and motion primitives.',
-        semantic: 'Contextual intent tokens such as primary action, muted surface, emphasis text, or critical state.',
-        component: 'Component-scoped tokens that consume semantic aliases and preserve local consistency without redefining the system.',
-      },
-      platformOutputs: ['json-contract', 'css-variables'],
     },
     colorTruth: {
       format: 'OKLCH',
@@ -253,19 +245,14 @@ function buildDesignIntentContractObject({
     motionSystem: {
       allowMeaningfulMotion: true,
       purpose: inferredKeywords.motionPurpose,
-      choreography: inferredKeywords.motionChoreography,
-      desktopDurationMs: inferredKeywords.motionDurations.desktop,
-      mobileDurationMs: inferredKeywords.motionDurations.mobile,
       seedToneLocked: false,
       respectReducedMotion: true,
-      preferTransformAndOpacity: true,
-      avoidDecorativeMotionForItsOwnSake: true,
     },
     componentMorphology: {
       requireStateBehaviorMatrix: true,
       preserveIdentityAcrossViewports: true,
       seedBehaviorsRequireRefinement: true,
-      stateKeys: ['default', 'hover', 'focus', 'active', 'disabled', 'loading', 'error'],
+      stateKeys: ['default', 'focus', 'loading', 'error'],
       viewportBehavior: inferredKeywords.componentMorphology,
     },
     accessibilityPolicy: {
@@ -322,45 +309,33 @@ function buildDesignIntentContractObject({
       status: 'seed-needs-refinement',
       seedMode: 'structure-first-scaffold',
       requiresTaskSpecificRefinement: true,
-      primaryExperienceGoal: `Ask the LLM to define the main ${String(primaryDomain || 'product').toLowerCase()} journey in ${projectName} from repo evidence, product context, user goals, and current official documentation where technology choices matter. This scaffold must not prescribe the final visual layout.`,
+      primaryExperienceGoal: `Define the main ${String(primaryDomain || 'product').toLowerCase()} journey for ${projectName} from repo evidence, the brief, and current docs. The seed must not prescribe final layout.`,
       surfacePlan: [
         {
           surfaceId: 'agent-defined-primary-experience',
-          role: 'llm-synthesized-from-current-context',
-          goal: `Define the primary UI experience for ${projectName} from the actual product task, audience, data, and repo evidence before coding.`,
-          primaryAction: 'The LLM must choose the first decisive action or reading path and explain why it fits the project.',
-          supportingModules: ['agent-defined-from-current-context'],
-          layoutAntiPatternToAvoid: 'template-default-without-product-rationale',
-          signatureMoveHint: 'Choose and document one project-specific visual, interaction, or content move. Do not inherit it from this scaffold.',
-        },
-        {
-          surfaceId: 'agent-defined-supporting-experience',
-          role: 'llm-synthesized-supporting-context',
-          goal: 'Define supporting, proof, utility, or recovery surfaces from actual user needs instead of cloning generic cards or rails.',
-          primaryAction: 'The LLM must decide what belongs beside, below, hidden behind disclosure, or removed based on task priority.',
-          supportingModules: ['agent-defined-from-current-context'],
-          layoutAntiPatternToAvoid: 'scale-only-responsive-layout',
-          signatureMoveHint: 'Explain how supporting content changes across viewports and why the change improves the experience.',
+          role: 'primary-context-synthesized-by-agent',
+          goal: 'Choose the first task or reading path from product evidence and reject template shells.',
+          antiPatterns: ['dashboard-default', 'scale-only-responsive-layout'],
         },
       ],
       componentGraph: {
         nodes: [
           {
-            id: 'agent-defined-primary-experience',
-            role: 'primary-experience-after-synthesis',
+            id: 'primary-experience',
+            role: 'agent-defined-primary',
             priority: 'high',
           },
           {
-            id: 'agent-defined-supporting-experience',
-            role: 'supporting-experience-after-synthesis',
+            id: 'supporting-context',
+            role: 'agent-defined-support',
             priority: 'medium',
           },
         ],
         edges: [
           {
-            from: 'agent-defined-primary-experience',
-            to: 'agent-defined-supporting-experience',
-            relationship: 'agent-defined-from-task-priority',
+            from: 'primary-experience',
+            to: 'supporting-context',
+            relationship: 'task-priority-support',
           },
         ],
       },
@@ -379,25 +354,21 @@ function buildDesignIntentContractObject({
         mobile: {
           primaryOperation: 'agent-defined-mobile-recomposition',
           requiredSurfaceActions: [
-            'choose-mobile-specific-task-order',
-            'merge-disclose-or-remove-low-priority-content',
-            'adapt-interaction-model-for-touch',
+            'choose-mobile-task-order',
+            'disclose-or-remove-low-priority-content',
           ],
           forbiddenPatterns: [
             'scale-only-shrink',
-            'desktop-order-preserved-without-priority-shift',
           ],
           rationale: inferredKeywords.mutationRules.mobile,
         },
         tablet: {
           primaryOperation: 'agent-defined-tablet-regrouping',
           requiredSurfaceActions: [
-            'define-medium-width-information-architecture',
-            'avoid-cloning-desktop-by-width-only',
+            'define-medium-width-grouping',
             'preserve-task-clarity',
           ],
           forbiddenPatterns: [
-            'desktop-layout-reduced-by-width-only',
             'uniform-module-grid-without-role-change',
           ],
           rationale: inferredKeywords.mutationRules.tablet,
@@ -406,11 +377,9 @@ function buildDesignIntentContractObject({
           primaryOperation: 'agent-defined-desktop-composition',
           requiredSurfaceActions: [
             'use-space-to-improve-hierarchy',
-            'define-scan-pattern-and-action-priority',
             'avoid-equalizing-unrelated-content',
           ],
           forbiddenPatterns: [
-            'template-shell-without-product-rationale',
             'interchangeable-dashboard-or-landing-chrome',
           ],
           rationale: inferredKeywords.mutationRules.desktop,
@@ -418,33 +387,25 @@ function buildDesignIntentContractObject({
       },
       interactionStateMatrix: [
         {
-          componentId: 'primary-action-control',
-          states: ['default', 'hover', 'focus', 'loading', 'success', 'error'],
-          notes: 'Refine these states with project-specific feedback language and visual treatment, but keep them legible, decisive, and consistent across all supported viewports.',
-        },
-        {
-          componentId: 'primary-content-module',
-          states: ['default', 'focus', 'expanded', 'loading', 'error'],
-          notes: 'Refine this module so it preserves hierarchy and progressive disclosure without collapsing into anonymous cards or safe default dashboard panels.',
+          componentId: 'primary-interaction',
+          states: ['default', 'hover', 'focus', 'loading', 'error'],
+          notes: 'Refine states from project language and the conceptual anchor; do not use anonymous default panels.',
         },
       ],
       taskFlowNarrative: [
-        `Entry: the LLM must define how ${projectName} starts the user journey from real product evidence instead of a generic opening pattern.`,
-        'Decision: the LLM must define hierarchy, proof, state language, and interaction behavior from the actual task.',
-        'Resolution: the LLM must define feedback, recovery, and next-useful-action behavior without defaulting to leftover template chrome.',
+        `Entry: define how ${projectName} starts the journey from real evidence, not a generic opener.`,
+        'Resolution: define proof, feedback, recovery, and next action without leftover template chrome.',
       ],
       visualResetStrategy: {
         activatesWhenUserRequests: [
           'redesign from zero',
           'redesain dari 0',
-          'ulang dari 0',
-          'research ulang',
         ],
-        existingUiAllowedAs: ['content-evidence', 'behavior-evidence', 'accessibility-evidence', 'asset-source-evidence'],
-        existingUiForbiddenAs: ['palette-source', 'typography-source', 'layout-source', 'motion-source', 'component-morphology-source'],
-        requiredResetAxes: ['composition', 'hierarchy', 'palette-and-typography', 'motion-or-interaction', 'responsive-information-architecture'],
+        existingUiAllowedAs: ['content-evidence', 'behavior-evidence', 'asset-source-evidence'],
+        existingUiForbiddenAs: ['palette-source', 'layout-source', 'motion-source'],
+        requiredResetAxes: ['composition', 'hierarchy', 'motion-or-interaction', 'responsive-information-architecture'],
       },
-      signatureMoveRationale: 'The LLM must choose the project-specific visual, motion, typographic, compositional, or interaction move after reading current context and explain why a generic fallback would weaken the product.',
+      signatureMoveRationale: 'Agent must choose one project-specific visual, motion, typographic, or interaction move and explain why generic fallback weakens it.',
       implementationGuardrails: {
         requireBuildFromHandoff: true,
         requireGapNotesBeforeFallback: true,
@@ -478,7 +439,7 @@ function buildDesignIntentContractObject({
         {
           key: 'motionDiscipline',
           blockingByDefault: false,
-          question: 'If motion is present, does it stay purposeful, performant, reduced-motion-safe, and consistent with the product tone?',
+          question: 'Does motion act as part of the design language while staying purposeful, performant, reduced-motion-safe, and consistent with the product tone?',
         },
       ],
       genericitySignals: [
@@ -486,21 +447,18 @@ function buildDesignIntentContractObject({
         'unresearched-library-or-framework-choice',
         'missing-conceptual-anchor-without-external-research',
         'visual-decisions-not-derived-from-conceptual-anchor',
-        'default-component-kit-treatment-without-product-rationale',
+        'timid-anchor-that-renames-dashboard-or-admin-shell',
+        'motion-suppressed-without-accessibility-or-performance-reason',
         'scale-only-responsive-layout',
-        'template-shell-without-product-rationale',
         'zero-based-redesign-kept-prior-visual-dna',
         'restyle-instead-of-recomposition',
-        'inaccessible-or-decorative-motion',
       ],
       validBoldSignals: [
         'single-cohesive-conceptual-anchor',
+        'high-variance-candidate-selection',
         'context-derived-visual-direction',
-        'official-docs-backed-library-choice',
         'responsive-recomposition-by-task-priority',
         'purposeful-motion-with-reduced-motion-path',
-        'documented-design-rationale-before-code',
-        'clean-component-and-token-architecture',
       ],
       reportingRules: {
         mustExplainGenericity: true,
@@ -528,10 +486,7 @@ function buildDesignIntentContractObject({
       approvedExternalConstraintUsage: 'Convert explicit user-supplied external constraints into current-project rules without comparing against or imitating the source surface.',
       driftSignals: [
         'palette-reused-without-brief-support',
-        'motion-signature-reused-without-approval',
-        'layout-shape-matches-unrelated-project-memory',
         'prior-ui-visual-dna-carried-into-reset-request',
-        'existing-design-doc-treated-as-style-continuity-during-zero-based-redesign',
       ],
     },
     experiencePrinciples: [
@@ -539,20 +494,17 @@ function buildDesignIntentContractObject({
       'Major interface decisions must be explainable in product and user terms.',
       'Accessibility, responsiveness, and implementation realism are non-negotiable.',
       'Cross-viewport behavior must reorganize tasks and navigation, not just scale the desktop layout down.',
-      'Modern libraries and interaction patterns may be used when the LLM verifies they fit the project and current official docs.',
-      'Motion may be rich and memorable when it improves the product experience, but it must stay purposeful, performant, and optional for reduced-motion users.',
-      'At least one visual, interaction, content, or motion decision must be recognizable at a glance and justified from context.',
-      'When no external design research is provided, a single advanced conceptual anchor must unify typography, spacing, morphology, motion, and responsive composition.',
+      'A single agent-chosen conceptual anchor must unify typography, spacing, morphology, motion, and responsive composition when user research is absent.',
+      'Expressive motion and spatial interaction are expected for modern UI work when they support the anchor; keep them accessible and performant instead of suppressing them by default.',
       'When the user asks for a zero-based redesign, existing UI becomes content and behavior evidence only; prior visual DNA must be discarded unless explicitly approved.',
     ],
     forbiddenPatterns: [
       'offline-prescribed-style-used-as-final-direction',
-      'unresearched-library-or-framework-choice',
       'missing-conceptual-anchor-without-external-research',
       'visual-decisions-not-derived-from-conceptual-anchor',
-      'default-component-kit-treatment-without-product-rationale',
+      'timid-anchor-that-renames-dashboard-or-admin-shell',
+      'motion-suppressed-without-accessibility-or-performance-reason',
       'scale-only-responsive-layout',
-      'template-shell-without-product-rationale',
       'zero-based-redesign-kept-prior-visual-dna',
       'restyle-instead-of-recomposition',
       'single-safe-typographic-family-without-role-contrast-or-rationale',
@@ -572,6 +524,8 @@ function buildDesignIntentContractObject({
       requireStructuredDesignHandoff: true,
       requireVisualResetStrategyWhenZeroBasedRedesignRequested: true,
       requireConceptualAnchorWhenNoExternalResearch: true,
+      requireAgentLedAnchorResearchWhenUserResearchMissing: true,
+      rejectTimidDashboardAnchor: true,
       requireReviewRubric: true,
       requireGenericityExplanation: true,
       genericityAutoFail: true,
@@ -652,6 +606,23 @@ export function validateDesignIntentContract(designIntentContract) {
     if (conceptualAnchor.requiresAgentSelectionBeforeUiImplementation !== true) {
       validationErrors.push('designIntent.conceptualAnchor.requiresAgentSelectionBeforeUiImplementation must equal true.');
     }
+    const userResearchAbsencePolicy = conceptualAnchor.userResearchAbsencePolicy;
+    if (!userResearchAbsencePolicy || typeof userResearchAbsencePolicy !== 'object') {
+      validationErrors.push('designIntent.conceptualAnchor.userResearchAbsencePolicy must exist.');
+    } else {
+      if (userResearchAbsencePolicy.userSuppliedResearchOnly !== true) {
+        validationErrors.push('designIntent.conceptualAnchor.userResearchAbsencePolicy.userSuppliedResearchOnly must equal true.');
+      }
+      if (userResearchAbsencePolicy.scaffoldSeedDoesNotCountAsResearch !== true) {
+        validationErrors.push('designIntent.conceptualAnchor.userResearchAbsencePolicy.scaffoldSeedDoesNotCountAsResearch must equal true.');
+      }
+      if (userResearchAbsencePolicy.priorUiDoesNotCountAsResearch !== true) {
+        validationErrors.push('designIntent.conceptualAnchor.userResearchAbsencePolicy.priorUiDoesNotCountAsResearch must equal true.');
+      }
+      if (userResearchAbsencePolicy.requireAgentLedResearchWhenAvailable !== true) {
+        validationErrors.push('designIntent.conceptualAnchor.userResearchAbsencePolicy.requireAgentLedResearchWhenAvailable must equal true.');
+      }
+    }
     const candidateSelectionPolicy = conceptualAnchor.candidateSelectionPolicy;
     if (!candidateSelectionPolicy || typeof candidateSelectionPolicy !== 'object') {
       validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy must exist.');
@@ -659,9 +630,18 @@ export function validateDesignIntentContract(designIntentContract) {
       if (candidateSelectionPolicy.considerAtLeast < 3) {
         validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.considerAtLeast must be at least 3.');
       }
+      if (candidateSelectionPolicy.discardObviousCandidateCount < 2) {
+        validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.discardObviousCandidateCount must be at least 2.');
+      }
+      if (candidateSelectionPolicy.minimumCandidateDistance !== 'high') {
+        validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.minimumCandidateDistance must equal "high".');
+      }
       if (candidateSelectionPolicy.discardPredictableCandidates !== true) {
         validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.discardPredictableCandidates must equal true.');
       }
+      if (candidateSelectionPolicy.preferDistinctiveOverSafe !== true) {
+        validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.preferDistinctiveOverSafe must equal true.');
+      }
       if (candidateSelectionPolicy.doNotRevealHiddenCandidateList !== true) {
         validationErrors.push('designIntent.conceptualAnchor.candidateSelectionPolicy.doNotRevealHiddenCandidateList must equal true.');
       }
@@ -673,6 +653,7 @@ export function validateDesignIntentContract(designIntentContract) {
       !Array.isArray(conceptualAnchor.forbiddenFinalAnchorTerms)
       || !conceptualAnchor.forbiddenFinalAnchorTerms.includes('dashboard')
       || !conceptualAnchor.forbiddenFinalAnchorTerms.includes('cards')
+      || !conceptualAnchor.forbiddenFinalAnchorTerms.includes('safe-admin-layout')
     ) {
       validationErrors.push('designIntent.conceptualAnchor.forbiddenFinalAnchorTerms must reject basic UI labels.');
     }
@@ -680,9 +661,28 @@ export function validateDesignIntentContract(designIntentContract) {
       !Array.isArray(conceptualAnchor.sourceDomains)
       || conceptualAnchor.sourceDomains.length < 4
       || !conceptualAnchor.sourceDomains.includes('complex-physical-engineering')
+      || !conceptualAnchor.sourceDomains.includes('cinematic-spatial-interface')
+      || !conceptualAnchor.sourceDomains.includes('premium-interactive-web-experiences')
     ) {
       validationErrors.push('designIntent.conceptualAnchor.sourceDomains must list broad non-template anchor domains.');
     }
+    const visualRiskBudget = conceptualAnchor.visualRiskBudget;
+    if (!visualRiskBudget || typeof visualRiskBudget !== 'object') {
+      validationErrors.push('designIntent.conceptualAnchor.visualRiskBudget must exist.');
+    } else {
+      if (visualRiskBudget.mode !== 'high-distinctiveness-with-accessibility-and-performance-guardrails') {
+        validationErrors.push('designIntent.conceptualAnchor.visualRiskBudget.mode must preserve high-distinctiveness guardrails.');
+      }
+      if (visualRiskBudget.allowRichMotionAndMicroInteraction !== true) {
+        validationErrors.push('designIntent.conceptualAnchor.visualRiskBudget.allowRichMotionAndMicroInteraction must equal true.');
+      }
+      if (visualRiskBudget.rejectTimidDefaultWhenAnchorSupportsExpressiveUi !== true) {
+        validationErrors.push('designIntent.conceptualAnchor.visualRiskBudget.rejectTimidDefaultWhenAnchorSupportsExpressiveUi must equal true.');
+      }
+      if (visualRiskBudget.requireReducedMotionFallback !== true) {
+        validationErrors.push('designIntent.conceptualAnchor.visualRiskBudget.requireReducedMotionFallback must equal true.');
+      }
+    }
     if (
       !Array.isArray(conceptualAnchor.requiredDerivedAxes)
       || !conceptualAnchor.requiredDerivedAxes.includes('typography')
@@ -696,10 +696,13 @@ export function validateDesignIntentContract(designIntentContract) {
     } else {
       if (
         !Array.isArray(finalAnchorContract.requiredFields)
+        || !finalAnchorContract.requiredFields.includes('agentResearchMode')
         || !finalAnchorContract.requiredFields.includes('derivedTokenLogic')
+        || !finalAnchorContract.requiredFields.includes('visualRiskBudget')
+        || !finalAnchorContract.requiredFields.includes('motionRiskBudget')
         || !finalAnchorContract.requiredFields.includes('cohesionChecks')
       ) {
-        validationErrors.push('designIntent.conceptualAnchor.finalAnchorContract.requiredFields must require derivedTokenLogic and cohesionChecks.');
+        validationErrors.push('designIntent.conceptualAnchor.finalAnchorContract.requiredFields must require agentResearchMode, derivedTokenLogic, visualRiskBudget, motionRiskBudget, and cohesionChecks.');
       }
       if (
         !Array.isArray(finalAnchorContract.derivedTokenLogicAxes)
@@ -708,6 +711,13 @@ export function validateDesignIntentContract(designIntentContract) {
       ) {
         validationErrors.push('designIntent.conceptualAnchor.finalAnchorContract.derivedTokenLogicAxes must include motion and morphology.');
       }
+      if (
+        !Array.isArray(finalAnchorContract.cohesionChecks)
+        || !finalAnchorContract.cohesionChecks.includes('no-dashboard-mental-model')
+        || !finalAnchorContract.cohesionChecks.includes('motion-derived-from-anchor')
+      ) {
+        validationErrors.push('designIntent.conceptualAnchor.finalAnchorContract.cohesionChecks must reject dashboard mental models and require motion derivation.');
+      }
     }
   }
 

package/lib/cli/project-scaffolder/prompt-builders.mjs

@@ -156,7 +156,7 @@ export function buildDesignBootstrapPrompt({
     '10. Do not let repeated surfaces, component-kit defaults, or safe typography become the final direction without explicit product rationale.',
     '11. The LLM must choose color, type, spacing, density, morphology, and motion dynamically from the active project context instead of copying this seed.',
     '12. Viewport mutation must be operation-based. For each viewport, define the primary mutation operation, required surface actions, and forbidden responsive fallback patterns.',
-    '13. Motion can be bold, cinematic, or highly expressive when it improves memorability, hierarchy, feedback, or product confidence. If a motion library is needed, research current official docs and select the latest stable compatible option instead of using an offline default. Only reject motion when it harms clarity, accessibility, or runtime performance.',
+    '13. Default to a rich motion plan for modern UI work. Motion can be bold, cinematic, spatial, scroll-linked, or highly expressive when it improves memorability, hierarchy, feedback, or product confidence. If a motion library is useful, research current official docs and select the latest stable compatible option instead of using an offline default. Solve clarity, accessibility, and runtime risks without falling back to a static interface by habit.',
     '14. Define component morphology across interaction states and viewports so cards, forms, nav, and feedback surfaces adapt coherently instead of only resizing.',
     '15. Keep UI-only requests context-isolated. Load frontend design rules first and do not eagerly load backend-only or workflow-only rules unless the task explicitly crosses those boundaries.',
     '16. Treat WCAG 2.2 AA as the hard accessibility floor. Use APCA only as advisory perceptual tuning, never as a reason to waive a WCAG failure.',
@@ -176,7 +176,9 @@ export function buildDesignBootstrapPrompt({
     '30. In zero-based redesign mode, the new contract must name the discarded prior visual DNA and materially reset composition, hierarchy, palette/typography, motion or interaction, and responsive information architecture.',
     '31. If modern UI, animation, scroll, 3D, canvas, chart, or icon libraries are useful, choose them from current official docs and record source URL, fetched date, reason, risk, and accessibility fallback.',
     '32. If the user supplies research files, library lists, screenshots, articles, or benchmark notes, read them as candidate evidence, summarize the useful signals, filter by project fit, and verify technology claims against current official docs before implementation.',
-    '33. If no external research or reference is supplied for UI work, choose one advanced conceptual anchor before coding. Consider multiple candidate anchors internally, discard predictable ones, output only the chosen anchor and rationale, and derive typography, spacing, morphology, motion, and responsive composition from that anchor.',
+    '33. If no user-supplied research or reference is supplied for UI work, activate the Dynamic Avant-Garde Anchor Engine before coding. User-supplied research means current-task evidence from the user; this scaffold, prior UI, and old design docs do not count as research.',
+    '34. In Dynamic Avant-Garde mode, perform agent-led research when available, then internally consider at least three high-variance conceptual anchors, discard the two safest or most predictable options, output only the chosen anchor and rationale, and forbid final anchors named dashboard, portal, cards, admin panel, SaaS shell, web app shell, or minimalist interface.',
+    '35. The chosen anchor must drive typography, spacing, density, color behavior, morphology, motion, and responsive composition. Treat expressive motion, spatial transitions, micro-interactions, and modern animation libraries as first-class options; include performance notes and reduced-motion fallbacks instead of suppressing motion to look safe.',
     '',
     '## Project Inputs',
     `- Project name: ${discoveryAnswers.projectName}`,
@@ -207,7 +209,8 @@ export function buildDesignBootstrapPrompt({
     '12. Keep visualResetStrategy in the machine-readable handoff so reset-language tasks cannot quietly become restyles of the previous UI.',
     '13. Preserve externalResearchIntake so user-provided research becomes reviewed evidence without turning into an offline style or dependency preset.',
     '14. Preserve conceptualAnchor so prompt-only UI work has one cohesive non-template concept instead of a mixed collection of bold but unrelated visual decisions.',
-    '15. After the contract exists, use it as a first-class source for future UI tasks.',
+    '15. Record conceptualAnchor.agentResearchMode, visualRiskBudget, motionRiskBudget, and cohesionChecks so the final UI cannot quietly fall back to a timid dashboard/admin mental model.',
+    '16. After the contract exists, use it as a first-class source for future UI tasks.',
     '',
   ].join('\n');
 }

package/lib/cli/token-optimization.mjs

@@ -89,6 +89,43 @@ const COMMAND_REWRITE_MAPPINGS = [
   },
 ];
 
+const OUTPUT_FOLDING_STRATEGY = {
+  mode: 'compact-high-signal-output',
+  appliesTo: [
+    'shell-command-output',
+    'test-output',
+    'build-output',
+    'diff-output',
+    'log-output',
+  ],
+  preserveAlways: [
+    'exit-code',
+    'failing-command',
+    'file-and-line',
+    'error-message',
+    'actionable-warning',
+  ],
+  foldByDefault: [
+    'repeated-success-lines',
+    'large-unchanged-diff-context',
+    'verbose-install-progress',
+    'duplicated-stack-frames',
+    'low-signal-directory-noise',
+  ],
+  nativeFallback: [
+    'prefer --stat or --name-only before full diff',
+    'prefer focused rg queries before broad file dumps',
+    'prefer failure-focused test reporters when available',
+    'summarize long logs before hydrating full detail',
+  ],
+  safetyBoundary: [
+    'never hide failing checks',
+    'never drop the command that produced output',
+    'never persist secrets into summaries',
+    'hydrate full output only when the compact summary is insufficient',
+  ],
+};
+
 function parseRtkVersion(versionOutput) {
   const versionMatch = versionOutput.match(/\d+\.\d+\.\d+/);
   return versionMatch ? versionMatch[0] : null;
@@ -204,6 +241,14 @@ export function createTokenOptimizationState({
       detectionError: rtkDetection.detectionError,
     },
     commandRewriteMappings: COMMAND_REWRITE_MAPPINGS.map((mapping) => ({ ...mapping })),
+    outputFoldingStrategy: {
+      ...OUTPUT_FOLDING_STRATEGY,
+      appliesTo: [...OUTPUT_FOLDING_STRATEGY.appliesTo],
+      preserveAlways: [...OUTPUT_FOLDING_STRATEGY.preserveAlways],
+      foldByDefault: [...OUTPUT_FOLDING_STRATEGY.foldByDefault],
+      nativeFallback: [...OUTPUT_FOLDING_STRATEGY.nativeFallback],
+      safetyBoundary: [...OUTPUT_FOLDING_STRATEGY.safetyBoundary],
+    },
     generatedAt: new Date().toISOString(),
   };
 }
@@ -258,6 +303,14 @@ export function buildTokenOptimizationGuidanceBlock(tokenOptimizationState) {
     '- If shell output is still large, summarize and continue iteratively instead of dumping full logs.',
   ];
 
+  const outputFoldingStrategy = tokenOptimizationState.outputFoldingStrategy || OUTPUT_FOLDING_STRATEGY;
+  const outputFoldingLines = [
+    `- Mode: ${outputFoldingStrategy.mode || OUTPUT_FOLDING_STRATEGY.mode}.`,
+    `- Preserve always: ${(outputFoldingStrategy.preserveAlways || OUTPUT_FOLDING_STRATEGY.preserveAlways).join(', ')}.`,
+    `- Fold by default: ${(outputFoldingStrategy.foldByDefault || OUTPUT_FOLDING_STRATEGY.foldByDefault).join(', ')}.`,
+    `- Safety boundary: ${(outputFoldingStrategy.safetyBoundary || OUTPUT_FOLDING_STRATEGY.safetyBoundary).join(', ')}.`,
+  ];
+
   return [
     `Token optimization mode is enabled for agent: ${tokenOptimizationState.selectedAgent}.`,
     `Preferred shell proxy: ${tokenOptimizationState.preferredShellProxy}.`,
@@ -269,6 +322,9 @@ export function buildTokenOptimizationGuidanceBlock(tokenOptimizationState) {
     '- Shell rewrite hooks affect shell tool calls only.',
     '- Built-in read/grep/glob style tools may bypass shell rewrites, so explicit compact shell commands should be preferred in high-volume sessions.',
     '',
+    'Output folding policy:',
+    ...outputFoldingLines,
+    '',
     'Fallback behavior when external proxy is unavailable:',
     ...fallbackGuidance,
   ].join('\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryuenn3123/agentic-senior-core",
-  "version": "3.0.23",
+  "version": "3.0.26",
   "type": "module",
   "description": "Force your AI Agent to code like a Staff Engineer, not a Junior.",
   "bin": {

package/scripts/ui-design-judge/prompting.mjs

@@ -14,7 +14,7 @@ export function buildSystemPrompt() {
     'Use repoEvidence.designEvidenceSummary as implementation evidence when deciding whether the diff follows the intended system.',
     'Do not reward generic SaaS defaults or popular template patterns.',
     'Do not penalize originality when the implementation still aligns with the contract.',
-    'Purposeful motion is allowed and can improve quality. Only flag motion when it drifts from the contract, ignores reduced-motion expectations, or adds avoidable performance/accessibility risk.',
+    'Treat purposeful motion as a first-class quality signal for modern UI work. Flag missing or timid motion when the contract calls for expressive interaction, and only flag motion itself when it drifts from the contract, ignores reduced-motion expectations, or adds avoidable performance/accessibility risk.',
     'Only flag drift when there is a clear mismatch with the contract, accessibility non-negotiables, or cross-viewport adaptation rules.',
     'Treat WCAG 2.2 AA failures as hard accessibility drift.',
     'Treat APCA as advisory perceptual tuning only. Do not set blocking solely because APCA indicates a stronger readability adjustment when WCAG hard requirements still pass.',